URI-Grammatik und Inventar der Formatzeichenketten
Aggrega-Entitäten referenzieren einander über URI-Strings, die an mehreren unterschiedlichen Authoring-Positionen erscheinen. Dieselbe URI-Form (core/postgres:1.0.0) erscheint in fünf oder mehr Kontexten von Entitätsarten, wobei der Compiler die Entitätsart aus der Schema-Position ableitet statt aus einem Sigil oder Präfix. Autoren, die eine YAML-Datei lesen oder pflegen, müssen die positionsbasierten Interpretationsregeln im Kopf behalten, um zu wissen, ob core/postgres:1.0.0 auf einen Component-Typ, ein Aggregate-Modul, ein Recipe, ein FeatureRecipe oder ein Wasm-Plugin verweist.
Diese Seite fasst die URI-Grammatik über alle Positionen hinweg zusammen, die Vorrangregeln für versionierte und unversionierte Schlüssel type: auf den Mapping-Ebenen des Manifest, die Inferenzregeln für OCI-URI-Kurzformen und das umfassendere Inventar der Formatzeichenketten im gesamten Korpus (Go-Template-Syntax, Sprig-Funktionen, Deklarationen nach JSON Schema 2020-12, JSONPath, Glob-Muster, SemVer-Regex). Autoren, die wissen müssen, „was macht Aggrega mit diesem String?“, sollten die Antwort hier finden.
Positionsbasierte Inferenz der Entitätsart
Derselbe URI-String hat je nach Position im Schema eine andere Bedeutung hinsichtlich der Entitätsart. Die folgende Tabelle führt jede Position auf, an der Aggrega eine URI als Entitätsreferenz erwartet, zusammen mit der abgeleiteten Entitätsart:
| Position | Abgeleitete Entitätsart | OCI-Pfaderweiterung |
|---|---|---|
Aggregate.spec.components.<id>.type | Component | /component/{publisher}/{category}/{name} |
Aggregate.spec.subsystems.<name>.components.<id>.type | Component (wie bei components — Subsysteme sind eine Gruppierung von Komponenten) | /component/{publisher}/{category}/{name} |
Aggregate.spec.aggregates.<id>.type | Aggregate (Sub-Aggregat-Modul) | /aggregate/{publisher}/{name} |
Aggregate.spec.components.<id>.features.<id>.type | Feature | /feature/{publisher}/{name} |
Aggregate.spec.components.<id>.features.<id>.type | Feature (Anmeldeinformation — mit dem Label feature.aggrega.ai/kind: secret) | /feature/{publisher}/{name} |
Manifest.spec.mappings.components.type.<key> | Component (die URI als Suchschlüssel); der Wert ist eine Recipe-URI | Schlüssel: /component/; Wert: /recipe/{provider}/{name} |
Manifest.spec.mappings.components.name.<id> | Recipe (granulare Override-Bindung) | /recipe/{provider}/{name} |
Manifest.spec.mappings.features.type.<key> | Feature (Suchschlüssel); der Wert ist eine FeatureRecipe-URI | Schlüssel: /feature/; Wert: /featurerecipe/{provider}/{name} |
Manifest.spec.mappings.features.name.<id> | FeatureRecipe (granulare Override-Bindung) | /featurerecipe/{provider}/{name} |
Manifest.spec.mappings.features.annotations.<key>.feature | Feature (an eine Annotation gebunden) | /feature/{publisher}/{name} |
Recipe.spec.implements | Component (Schnittstellenvertrag) | /component/{publisher}/{category}/{name} |
FeatureRecipe.spec.implements | Feature (Schnittstellenvertrag) | /feature/{publisher}/{name} |
Component.spec.extends / Feature.spec.extends | Component / Feature (Elternteil in der Vererbungskette) | /component/{publisher}/{category}/{name} oder /feature/{publisher}/{name} |
Manifest.spec.extends | Manifest (Elternteil in der Mapping-Vererbungskette) | keine URI-Position — ein relativer Pfad oder der bloße metadata.name eines Manifest neben dem Release |
Release.spec.extends | Release (Elternteil in der Vererbungskette) | keine URI-Position — ein relativer Pfad zu einer Release-Datei und keine andere Form |
Release.spec.aggregate | Aggregate (das Bereitstellungsziel des Release) | /aggregate/{publisher}/{name} |
Release.spec.manifest | Manifest (die Mapping-Lockfile des Release) | keine URI-Position — ein relativer Pfad oder der bloße metadata.name eines Manifest neben dem Release |
FeatureRecipe.spec.pipeline.<step>.plugin | Wasm-Plugin | /plugin/{pluginType}/{name} |
Drei Positionen sind aufgeführt, weil Autoren dort eine URI erwarten, und doch sind sie keine. Ein Manifest und ein Release sind Dokumente der Bereitstellungsseite, die nebeneinander verfasst werden, statt im Katalog indizierte Entitäten zu sein, sodass weder das extends: des einen noch das des anderen und auch kein manifest: eines Release gegen den Katalog oder eine Registry aufgelöst wird. Das manifest: eines Release nennt eine Datei oder den bloßen metadata.name eines Manifest, das neben dem Release liegt. An den beiden Positionen extends: nennt der Wert eine Datei, und eine an einer der beiden geschriebene Registry-Koordinate wird abgelehnt, wobei die Diagnose die akzeptierte Form nennt. Die beiden Positionen extends: werden auch nicht gleich geschrieben — ein Manifest akzeptiert auch den bloßen metadata.name eines Manifest, das neben dem Release liegt, während ein Release den relativen Pfad akzeptiert und nichts anderes. Siehe entities/release.md für die Form des Release und errors/fatal-halts.md dafür, was jede Ablehnung besagt.
Die Inferenzregel: Die Position im YAML-Schema bestimmt die Entitätsart. Es gibt keine Markierung an der Oberfläche (Sigil, Präfix, Annotation auf Schema-Ebene), die dem Autor sagt, auf welche Entitätsart ein bestimmtes Feld type: verweist. Autoren behalten beim Lesen von YAML die positionsbasierten Regeln im Kopf; Werkzeuge (Editor-Vervollständigung, aggrega inspect) lesen dieselben Regeln, um für die Entitätsart spezifische Vorschläge anzuzeigen.
Zwei URI-Formen — Plugins mit abgeleiteten Koordinaten vs. Katalogentitäten mit der Art in den Metadaten
Eine URI einer Katalogentität trägt kein Sigil für die Art (der vorige Abschnitt). Plugin-URIs sind das bewusste Gegenstück: Eine Plugin-URI schreibt sehr wohl ein klassifizierendes Segment — ihren Socket-Typ — direkt in den Pfad. Die beiden Referenzfamilien lesen sich absichtlich unterschiedlich, und zu wissen, zu welcher Familie eine URI gehört, sagt Ihnen, wo Sie nach ihrer Klassifizierung suchen müssen.
Plugin-Koordinaten werden aus dem Typ des Plugins abgeleitet. Eine Plugin-Referenz ist oci://hub.aggrega.ai/plugin/<pluginType>/<name>. Die Koordinate ist abgeleitet: Das Segment <pluginType> und der bloße <name> stammen aus dem Adressierungsblock des Plugins — metadata.pluginType und metadata.name — und werden zum Pfad zusammengesetzt. Der Socket wird nicht als Pfad in den Namen codiert; metadata.name ist der bloße Name. Die abgeleitete Koordinate IST der Schlüssel der Registry (und der Menge eingebetteter Plugins), sodass die Registry Plugins nach Socket organisiert. Core-Plugins werden zu Koordinaten wie plugin/provider/helm, plugin/linter/publishing und plugin/parser/yaml aufgelöst — jeweils die Zusammensetzung eines bloßen metadata.name (helm, publishing, yaml) mit seinem metadata.pluginType (provider, linter, parser). Das Segment <pluginType> ist genau der Socket-Typ des Plugins: Derselbe bloße <name> unter einem anderen pluginType ist ein anderes Plugin, weil sich die abgeleitete Koordinate — und damit die Identität — unterscheidet. Die vollständige Socket-Taxonomie, nach der das Segment <pluginType> klassifiziert, finden Sie unter entities/plugin.md.
Katalogentitäten tragen die Art in den Metadaten. Die verfasste Referenz ist <publisher>/<category>/<name> (zum Beispiel core/datastore/postgres). Das kind: der Entität steht in der Datei; die Entitätsart der URI wird aus der Schema-Position abgeleitet, gemäß Positionsbasierte Inferenz der Entitätsart weiter oben. Der Pfad ist nach Kategorie organisiert, nicht nach Art: Eine Component trägt ein Kategoriesegment (core/datastore/postgres); ein Recipe oder FeatureRecipe trägt seine Render-Fähigkeit als erstes Segment (helm/postgres); die übrigen Arten sind flach, <publisher>/<name>. Nichts im Pfad schreibt die Entitätsart aus.
Warum sich die beiden Formen unterscheiden. Plugins sind in der Registry nach Socket organisiert, daher ist das Socket-Segment der natürliche Registry-Schlüssel und in jeder Plugin-URI vorhanden. Katalogentitäten sind in der Registry nach Kategorie organisiert, daher ist es die Kategorie — nicht die Art —, die der Pfad ausschreibt. Eine URI verrät Ihnen also den Socket eines Plugins allein aus dem Pfad, die Art einer Katalogentität aber erst, nachdem Sie die Datei gelesen haben (die Art steht in metadata, die Position liefert sie an einer Referenzstelle). Diese Asymmetrie ist beabsichtigt: Der Pfad jeder Familie spiegelt wider, wie diese Familie in der Registry organisiert ist, und nicht eine einzige einheitliche Grammatik, die beiden auferlegt wird.
URI-Form — versioniert vs. unversioniert
Jede der obigen URI-Positionen akzeptiert eine Referenz in einer von drei Formen — unversioniert oder nach einem Doppelpunkt mit einer exakten Version oder einem Caret-Bereich gepinnt:
| Form | Beispiel | Semantik |
|---|---|---|
| Ohne Version | core/postgres | Wird zu „beliebige Version“ oder „zuletzt registrierte“ aufgelöst, je nach der Auflösungssemantik der Position |
| Exakter Pin | core/postgres:1.0.0 | Pinnt auf eine bestimmte Version. Die Version ist eine semantische Version, die Form, die das metadata.version jeder Entität hat |
| Caret-Pin | core/postgres:^1.0.0 | Wählt die höchste Version, die mit der genannten kompatibel ist — für ^1.0.0 mindestens 1.0.0 und unter 2.0.0 |
Der Pin ist der Text nach dem letzten Doppelpunkt der Referenz, und nur dann, wenn dieser Text kein / enthält. Eine Referenz auf einen Registry-Host mit Port — localhost:5000/core/postgres — trägt daher keinen Pin: Der Text nach dem Doppelpunkt des Ports setzt die Referenz fort.
Ein Pin, der keine dieser Formen hat — ein Caret, dessen Text sich nicht als Versionsbereich lesen lässt (core/postgres:^garbage), oder ein exakter Pin, der keine semantische Version ist (core/postgres:1.x, core/postgres:1.0, core/postgres:v1.0.0) —, nennt überhaupt keine Version. Wenn ein Befehl eine solche Referenz auflöst und sie sich nicht auflösen lässt, nennt die Ablehnung die Referenz, den Pin und die drei obigen Formen, statt eine Entität oder Version zu melden, die der Katalog nicht enthält; die Diagnose ist in errors/fatal-halts.md unter „A version pin is none of the forms a pin takes (Ein Versions-Pin hat keine der Formen, die ein Pin annimmt)“ beschrieben. Der Pin wird nur dort beurteilt, sodass ein fehlerhafter Pin nie ändert, welche Referenzen aufgelöst werden, und ein wohlgeformter Pin, den keine verfügbare Version erfüllt, als solcher gemeldet wird. Kein Schema legt die Pin-Grammatik fest, daher wird ein fehlerhafter Pin gemeldet, wenn etwas die Referenz auflöst — aggrega validate, aggrega pull, aggrega build —, und nicht, wenn die Datei geladen wird.
Die Formen bestehen an derselben Position nebeneinander. Autoren wählen danach, ob sie Versions-Pinning oder Versionsflexibilität benötigen. Die Ebene mappings.{components,features}.type des Manifest unterstützt beide Varianten als unterschiedliche Wörterbuchschlüssel mit dem Vorrang versioniert gewinnt vor unversioniert — ein versionierter Schlüssel (core/api-server:1.0.0) hat Vorrang vor dem unversionierten Schlüssel (core/api-server), wenn beide auf dieselbe Suche passen. Die beiden Varianten schließen sich nicht aus; beide können in derselben Map type: stehen, und der Resolver wählt die spezifischste. Der Provider-Dispatch ergibt sich aus dem Feld spec.capability des aufgelösten Recipe, sodass das Manifest einen Typ auf ein Recipe abbildet und nicht mehr.
Zum Regime der Versionsnutzung pro Entität (bei welchen Entitäten das Versionsfeld tatsächlich vom Auflösungs-Dispatch genutzt wird und bei welchen es nur beschreibende Herkunftsangabe ist) siehe vocabulary/inheritance-and-interface.md „Cross-entity version consumption (Entitätsübergreifende Nutzung von Versionen)“.
Eine Referenz auf eine Component, ein Feature, ein Aggregate oder ein Plugin akzeptiert auch einen Caret-Bereich (core/postgres:^1.0.0), und gleich welche Form sie hat, wählt sie die höchste passende Version unter denen, die der Katalog enthält, nach einer einzigen Regel, die jeder Befehl anwendet — siehe version-resolution.md. Zum dreiformigen Abgleich von implements:, der die Konsistenzprüfung einer Zuordnung und keine Auswahl ist, siehe 10-status.md „Version matching (Versionsabgleich)“.
Identität, nicht Ort
Eine kanonische Entitätsreferenz — einschließlich einer Plugin-Referenz — ist eine Identität, kein Ort: Sie nennt, was die Entität ist, nie, wo sie sich gerade befindet.
Die Identität ist bloß und hostfrei. Sie trägt keinen Registry-Host; der Host ist eine Auflösungskoordinate, die von der Konfiguration über default_registry geliefert und zum Auflösungszeitpunkt gebunden wird. Eine Registry zu verlagern oder dieselbe Entität anderswo zu spiegeln, ist eine Konfigurationsänderung — die Referenzen, die die Entität nennen, bleiben unberührt.
Die Identität ist außerdem versionsfrei. Eine Referenz kann einen optionalen Versions-Pin (:<version> oder :^<version>) tragen, um einzuschränken, welche Versionen sie erfüllen, und jedes Release hält die exakt aufgelöste Version als Pin in seiner Lockfile fest, doch die Version wird neben der Identität geliefert, statt in sie eingebacken zu werden.
Zum Auflösungszeitpunkt verbindet der Compiler die bloße Identität mit dem konfigurierten Host und der gepinnten Version, um zu konkreten Bytes zu gelangen. Da beide getrennt geliefert werden, wird dieselbe Referenz gegen eine andere Registry oder eine andere gepinnte Version aufgelöst, ohne dass die Quelle, die sie nennt, bearbeitet wird.
Inferenz von OCI-URI-Kurzformen
Autoren müssen nicht jede URI als vollqualifizierte OCI-URI ausschreiben. Der Compiler wendet vier orthogonale Inferenzregeln an, um Kurzformen des Authorings zum Auflösungszeitpunkt zu kanonischen OCI-URIs zu erweitern. Die Regeln:
Regel 1 — Standarddomäne
Jeder URI ohne Domäne wird das konfigurierte default_registry aus .aggrega-config.yaml vorangestellt (Standard: hub.aggrega.ai/).
# Shorthandtype: core/postgres:1.0.0
# Equivalent canonical formtype: hub.aggrega.ai/component/core/postgres:1.0.0Regel 2 — Kontextabhängige Entitätserweiterung
Der Compiler hängt anhand der Schema-Position das korrekte Segment der Entitätsart an. Die Zuordnung ist dieselbe wie in der obigen Tabelle zur Positionsinferenz (/component/, /aggregate/, /recipe/, /featurerecipe/, /feature/, /plugin/).
# Same string, two positions, two expansionsAggregate.spec.components.foo.type: core/postgres:1.0.0# → hub.aggrega.ai/component/core/postgres:1.0.0
Manifest.spec.mappings.components.type."core/postgres:1.0.0": helm/postgres:1.0.0# Key: hub.aggrega.ai/component/core/postgres:1.0.0# Value: hub.aggrega.ai/recipe/helm/postgres:1.0.0Regel 3 — Dreistufiger Vorrang
Vor der Anwendung der OCI-Inferenz löst der Compiler die URI über das dreistufige Modell der Entitätsauflösung auf, das in architecture/13-catalog-and-registry.md dokumentiert ist:
- Lokaler Pfad — für die Dokumente, die ein Release und sein Manifest nennen.
aggregate,manifestoderextendseines Release oderextendseines Manifest, geschrieben mit einem Präfix./oder../, werden als Datei relativ zum eigenen Verzeichnis des Release gelesen; die OCI-Inferenz läuft nicht. Keine andere Position nimmt einen Pfad an: Eintype, ein Schlüssel oder Wert eines Manifest-Mappings, einimplementsoder einplugineiner Pipeline, geschrieben als./…, nennt keine Entität und bricht den Build ab. Eine lokal verfasste Entität wird untercatalog/im Workspace-Stammverzeichnis oder in einem Verzeichnis abgelegt, dasworkspace.catalog_dirsauflistet, und wird über ihren Namen durch die Stufe aus Workspace und Cache aufgelöst. - Workspace und Cache — der Katalog-Such-Stack des Workspace, dann der Cache. Die Verzeichnisse
catalog_dirs:des Workspace aus.aggrega-config.yaml— oder, für ein Release, dem die Konfiguration unterworkspace.releaseseigene Verzeichnisse gibt, die des betreffenden Release — werden in der geschriebenen Reihenfolge durchsucht, und das Verzeichniscatalog/des Workspace-Stammverzeichnisses wird zuletzt durchsucht — nach jedem aufgeführten Eintrag und nur, wenn dieses Verzeichnis existiert. Ein Treffer irgendwo im Stack schließt die OCI-Inferenz kurz. Ein Fehltreffer zieht danachartifact_cache_dirheran, das enthält, was frühere Registry-Pulls abgerufen haben. - Registry. Wenn die Stufe aus Workspace und Cache keinen Treffer liefert, greifen die OCI-Inferenzregeln, und die Referenz wird von
aggrega pullaus der entfernten Registry abgerufen oder von einem Build, der mit--auto-pulloder der Workspace-Einstellungauto_pullläuft; ein Build ohne beides liest nur, was seine Lockfile pinnt.
Die Kaskade erlaubt einem Projekt, die Dokumente, die ein Release per Pfad nennt (die Stufe des lokalen Pfads), mit vendored und Workspace-lokalem Kataloginhalt (die Stufe aus Workspace und Cache) und aus der Ferne abgerufenem Registry-Inhalt (die Stufe der Registry) zu mischen, und eine Entitätsreferenz wird gleich geschrieben, welche der letzten beiden Stufen die Entität auch enthält.
Wenn catalog_dirs: mehr als ein Verzeichnis auflistet, ist die Liste ein geordneter Vorrang-Stack nach dem Prinzip „der Erste gewinnt“: Eine Entitätsidentität, die in mehr als einem aufgeführten Verzeichnis vorkommt, wird zum zuerst aufgeführten Verzeichnis aufgelöst, und das spätere Vorkommen wird überschattet (überschrieben, kein Fehler) — so kann ein Projekt sein eigenes Katalogverzeichnis vor ein gemeinsam genutztes legen und Entitäten anhand ihrer Identität überschreiben, während der Rest durchfällt. Die Überschreibung wird im Auflösungsdetail gemeldet. Zwei Dateien, die innerhalb eines einzigen Verzeichnisses dieselbe Identität beanspruchen, bleiben ein Authoring-Fehler, der das Laden anhält.
Das Verzeichnis catalog/ des Workspace-Stammverzeichnisses steht am Ende dieses Stacks statt an seinem Anfang, sodass alles, was ein Projekt auflistet, bei einer Kollision davor Vorrang hat, und das Auflisten eines unabhängigen Verzeichnisses verhindert nie, dass es gelesen wird. Es wird übersprungen, wenn ein aufgeführter Eintrag es bereits erreicht — das Durchlaufen eines aufgeführten Verzeichnisses ist rekursiv, sodass ein Stack, der das Workspace-Stammverzeichnis nennt, es bereits gelesen hat. catalog_dirs: wegzulassen und es als leere Liste zu schreiben, sind unterschiedliche Aussagen: Weggelassen liest der Workspace weiterhin catalog/; als [] geschrieben, liest er überhaupt keinen lokalen Katalog, und so erklärt ein Workspace, dass er keinen hat.
Regel 4 — Versionsbehandlung
Eine URI kann das Versionssegment enthalten oder weglassen. Die Versionsbehandlung hängt von der Auflösungsposition ab (Auflösung der Manifest-Ebene, Abgleich von implements:, Import von Sub-Aggregaten), gemäß den eigenen Regeln der Position zur Versionsnutzung. Siehe inheritance-and-interface.md „Cross-entity version consumption (Entitätsübergreifende Nutzung von Versionen)“ zur Versionssemantik pro Entität.
Inventar der Formatzeichenketten
Über URI-Strings hinaus umfasst die Authoring-Oberfläche von Aggrega mehrere unterschiedliche Konventionen für Formatzeichenketten. Autoren, die YAML-Dateien schreiben oder lesen, begegnen den folgenden Formaten an verschiedenen Positionen:
| Format | Wo verfasst | Validiert durch |
|---|---|---|
Go-Template ({{ .field }}) | Recipe valuesMapping: / workload: / artifacts: / provides: / locals: / source:; FeatureRecipe injectMapping: / with: der Pipeline; Interpolation in parameters: des Aggregate; Release directory: / subDirectory: | Go-Template-Parser zum Auswertungszeitpunkt; Verfügbarkeitsregeln pro Stelle unter templates/expansion-matrix.md |
Sprig-Funktionsreferenz ({{ default 1 .v }} usw.) | Dieselben Oberflächen wie Go-Templates | Sprig-v3-FuncMap, bei der Initialisierung der Template-Engine registriert; vollständige Helper-Liste unter templates/sprig-functions.md |
| JSON Schema 2020-12 (kompakte oder vollständige Form) | Inhalt von schema: einer Component / eines Feature (oder ein $ref: auf einen Eintrag einer SchemaLibrary) | JSON-Schema-Validator beim Laden der Entität während der Auflösung |
| JSON Pointer (RFC 6901) | Schlüssel locals.<*_path>: eines Recipe (volumes_path, containers_path usw.); Verweise auf Schrittausgaben von pipeline: eines FeatureRecipe; JSONPatch-Payloads von Wasm-Plugins | RFC-6901-Grundlage gemäß dem Vertrag für Wasm-Plugins; deklariert in plugins/plugin-contract.md |
| SemVer-Regex | Felder metadata.version an jeder Entität | JSON-Schema-Regex ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-...)?$ pro Entitätsschema |
Versions-Pin (:<version>, :^<version>) | Das Versionssegment einer Entitätsreferenz, an jeder obigen URI-Position | Der Compiler, wenn er die Referenz auflöst: Ein exakter Pin ist eine semantische Version und der Bereich eines Caret-Pins lässt sich parsen, und ein fehlerhafter Pin wird unter seiner eigenen Bedingung abgelehnt — siehe URI-Form weiter oben |
| Dateisystempfad | Katalogrelative Pfade (z. B. Einträge catalog_dirs: in .aggrega-config.yaml); Dateipfade $import: eines Recipe in workload: / artifacts: / valuesMapping: | Bei der Auflösung so gelesen, wie geschrieben — ein Eintrag catalog_dirs: relativ zur Konfigurationsdatei, die ihn deklariert, ein Pfad $import: relativ zum eigenen Verzeichnis der Entität; kein Glob wird erweitert, daher nennt ein * eine Datei oder ein Verzeichnis dieses Namens |
| Label-Selektor-Ausdruck | Component.spec.usesSchema.<socket>.selector; appliesTo: / appliesToAnyOf: eines Feature | Selektor-Parser von Aggrega dort, wo der Selektor ausgewertet wird; Selektor-Grammatik dokumentiert unter vocabulary/modifier-system.md |
Form des Annotationsschlüssels (<namespace>/<name>) | Schlüssel metadata.annotations; Schlüssel features.annotations des Manifest; Annotationskaskade der Boundary | JSON-Schema-Regex pro Entität; Disziplin der reservierten Präfixe unter vocabulary/labels-and-annotations.md |
Provider-Name, optional mit Versions-Pin (helm, helm:^1.0.0) | Recipe.spec.capability; FeatureRecipe.spec.capability | Provider-Dispatch-Suche; ein Pin, den keine Plugin-Version erfüllt, bricht den Build ab |
Inject-Zustellungsschlüssel (env.<KEY>, file.<path>, arg.<flag>) | Blöcke inject: eines Aggregate; Ausgabe von injectMapping: eines FeatureRecipe | Inject-Schema unter vocabulary/topology-triad.md |
Jedes Format hat seine eigene Grammatik, seinen eigenen Validator und seine eigene Form der Fehlermeldung. Autoren, die auf einen Parse-Fehler einer Formatzeichenkette stoßen, lesen die Referenz des jeweiligen Formats für die Syntaxregeln.
Der Editor meldet diese Fehler, während Sie schreiben: aggrega serve validiert jedes Dokument, das ihm gesendet wird, gegen das Schema seiner Art und liefert dasselbe Urteil, das ein Build fällen würde (siehe cli/aggrega-serve.md „Live validation (Live-Validierung)“), und aggrega scaffold entwirft ein Startdokument jeder Art.
Querverweise
entities/manifest.md— Auflösung der Mapping-Ebene des Manifest + der Abschnitt zu kontextabhängigen Kurz-URIs.entities/plugin.md— Plugin-Socket-Taxonomie + die socketcodierte URI-Formplugin/<socket>/<name>.architecture/13-catalog-and-registry.md— dreistufiges Modell der Entitätsauflösung + kanonische OCI-Taxonomie für die Verteilung des Katalogs.vocabulary/inheritance-and-interface.md— Interface-Bindung überimplements:+ entitätsübergreifende Nutzung von Versionen.templates/expansion-matrix.md— Verfügbarkeitsregeln pro Template-Stelle für Formatzeichenketten von Go-Templates.templates/sprig-functions.md— Inventar der Sprig-v3-Helper, die in die Template-Engine eingebunden sind.vocabulary/topology-triad.md— Konventionen für Inject-Zustellungsschlüssel; die Grammatik der Selektor-Ausdrücke steht untervocabulary/modifier-system.md.vocabulary/labels-and-annotations.md— Form des Annotationsschlüssels und Disziplin der reservierten Präfixe.10-status.md— Reifegrad des dreiformigen Abgleichs vonimplements:und der CLI-Befehle, die Referenzen auflösen.