@hypit/hypit 0.0.1 → 0.1.1

package/dist/public/text.d.ts

@@ -0,0 +1,817 @@
+/** Opaque identity for one admitted byte resource. Equal bytes may have different identities. */
+type ResourceId = `res_${string}`;
+type RecordId = string;
+type StepId = string;
+type CommandId = string;
+type ModuleRef = {
+    readonly name: string;
+    readonly version: string;
+};
+/**
+ * A Type is its owning Module and its name, and nothing else is compared. Two Types whose values
+ * carry identical shapes are distinct, so one is refused where the other is declared — there is no
+ * structural fallback to fall back to.
+ */
+type TypeRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+type ProducerRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+type CapabilityRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+
+type CanonicalValue = null | boolean | number | string | readonly CanonicalValue[] | {
+    readonly [key: string]: CanonicalValue;
+};
+type BlobRef = {
+    readonly kind: "blob";
+    /** One admitted resource instance. Equal bytes admitted twice keep distinct identities. */
+    readonly resource: ResourceId;
+    readonly size: number;
+    readonly mediaType: string;
+};
+type StoredValue = {
+    readonly kind: "inline";
+    readonly value: CanonicalValue;
+} | BlobRef;
+
+type ModuleDependency = {
+    readonly module: ModuleRef;
+};
+type TypeDeclaration = {
+    readonly name: string;
+};
+type PortDeclaration = {
+    readonly name: string;
+    readonly type: TypeRef;
+};
+type NeedPortDeclaration = {
+    readonly name: string;
+    readonly capability: CapabilityRef;
+    readonly returns: TypeRef;
+};
+type CapabilityDeclaration = {
+    readonly name: string;
+    readonly returns: TypeRef;
+};
+type ProducerDeclaration = {
+    readonly name: string;
+    readonly inputs: readonly PortDeclaration[];
+    readonly outputs: readonly PortDeclaration[];
+    readonly needs: readonly NeedPortDeclaration[];
+};
+type ModuleManifest = {
+    readonly format: "hypit.module@1";
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies: readonly ModuleDependency[];
+    readonly types: readonly TypeDeclaration[];
+    readonly capabilities: readonly CapabilityDeclaration[];
+    readonly producers: readonly ProducerDeclaration[];
+};
+type ResolvedModule = {
+    readonly manifest: ModuleManifest;
+};
+type ResolvedModuleClosure = {
+    readonly format: "hypit.closure@1";
+    readonly modules: readonly ResolvedModule[];
+};
+
+type SourceRange = {
+    readonly start: number;
+    readonly end: number;
+};
+/** One typed value in the graph; semantic validation happens at the Host admission boundary. */
+type TypedRecord = {
+    readonly id: RecordId;
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+type InvokeProducerCommand = {
+    readonly kind: "invoke-producer";
+    readonly id: CommandId;
+    readonly step: StepId;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, RecordId>>;
+};
+
+type TypeValidatorContext = {
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+/**
+ * Pure compute context. Artifact bytes, credentials, network and stores are deliberately absent;
+ * those effects must cross an explicit Need into a Provider.
+ */
+type ProducerHandlerContext = {
+    readonly command: InvokeProducerCommand;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, TypedRecord>>;
+};
+
+type Text = {
+    readonly value: string;
+};
+type TextScalar = string | number | boolean;
+type TextBindingValue = TextScalar | readonly TextScalar[];
+type TextBindings = {
+    readonly values: Readonly<Record<string, TextBindingValue>>;
+};
+/** Instructions for attaching one graph Text edge to a named template input. */
+type TextBinding = {
+    readonly name: string;
+    readonly mode: "set" | "append";
+};
+type TextCondition = {
+    readonly kind: "present";
+    readonly binding: string;
+} | {
+    readonly kind: "equals";
+    readonly binding: string;
+    readonly value: TextScalar;
+} | {
+    readonly kind: "all";
+    readonly conditions: readonly TextCondition[];
+} | {
+    readonly kind: "any";
+    readonly conditions: readonly TextCondition[];
+} | {
+    readonly kind: "not";
+    readonly condition: TextCondition;
+};
+type TextTransform = {
+    readonly kind: "trim";
+} | {
+    readonly kind: "trim-start";
+} | {
+    readonly kind: "trim-end";
+} | {
+    readonly kind: "uppercase";
+} | {
+    readonly kind: "lowercase";
+} | {
+    readonly kind: "collapse-whitespace";
+} | {
+    readonly kind: "normalize-newlines";
+} | {
+    readonly kind: "json-string";
+};
+type TextExpression = {
+    readonly kind: "literal";
+    readonly value: string;
+} | {
+    readonly kind: "slot";
+    readonly binding: string;
+} | {
+    readonly kind: "sequence";
+    readonly items: readonly TextExpression[];
+} | {
+    readonly kind: "join";
+    readonly separator: string;
+    readonly omitEmpty?: boolean;
+    readonly items: readonly TextExpression[];
+} | {
+    readonly kind: "choice";
+    readonly cases: readonly {
+        readonly when: TextCondition;
+        readonly value: TextExpression;
+    }[];
+    readonly otherwise?: TextExpression;
+} | {
+    readonly kind: "optional";
+    readonly when: TextCondition;
+    readonly value: TextExpression;
+} | {
+    readonly kind: "each";
+    readonly binding: string;
+    readonly as: string;
+    readonly separator: string;
+    readonly value: TextExpression;
+} | {
+    readonly kind: "replace";
+    readonly input: TextExpression;
+    readonly replacements: readonly {
+        readonly from: string;
+        readonly to: string;
+        readonly mode: "first" | "all";
+    }[];
+} | {
+    readonly kind: "transform";
+    readonly input: TextExpression;
+    readonly transforms: readonly TextTransform[];
+} | {
+    readonly kind: "call";
+    readonly template: string;
+};
+/**
+ * A finite, data-only text program. Definitions share the caller's explicit
+ * bindings; `call` cannot pass hidden state or execute arbitrary code.
+ */
+type TextTemplate = {
+    readonly root: TextExpression;
+    readonly defaults?: Readonly<Record<string, TextBindingValue>>;
+    readonly definitions?: Readonly<Record<string, TextExpression>>;
+};
+
+declare const textComponent: {
+    validators: {
+        type: {
+            module: {
+                readonly name: "@hypit/text";
+                readonly version: "1";
+            };
+            name: string;
+        };
+        handler: ({ value }: TypeValidatorContext) => void;
+    }[];
+    producers: ({
+        producer: {
+            module: {
+                readonly name: "@hypit/text";
+                readonly version: "1";
+            };
+            name: string;
+        };
+        handler: ({ inputs }: ProducerHandlerContext) => {
+            outputs: {
+                bindings: {
+                    kind: "inline";
+                    value: TextBindings;
+                };
+            };
+            needs: {};
+        };
+    } | {
+        producer: {
+            module: {
+                readonly name: "@hypit/text";
+                readonly version: "1";
+            };
+            name: string;
+        };
+        handler: ({ inputs }: ProducerHandlerContext) => {
+            outputs: {
+                text: {
+                    kind: "inline";
+                    value: Text;
+                };
+            };
+            needs: {};
+        };
+    })[];
+};
+
+type FragmentInputRef = {
+    readonly kind: "fragment-input";
+    readonly name: string;
+};
+type FragmentOperationRef = {
+    readonly kind: "fragment-operation";
+    readonly operation: string;
+};
+type FragmentValueRef = FragmentInputRef | FragmentOperationRef;
+type FragmentOperationResult = {
+    readonly kind: "output";
+    readonly name: string;
+} | {
+    readonly kind: "need";
+    readonly name: string;
+};
+type FragmentOperation = {
+    readonly id: string;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, FragmentValueRef>>;
+    readonly result: FragmentOperationResult;
+};
+type FragmentExport = {
+    readonly name: string;
+    readonly type: TypeRef;
+    readonly root: FragmentOperationRef;
+};
+type GraphFragment = {
+    readonly format: "hypit.fragment@1";
+    readonly id: string;
+    readonly inputs: readonly {
+        readonly name: string;
+        readonly type: TypeRef;
+    }[];
+    readonly operations: readonly FragmentOperation[];
+    readonly exports: readonly FragmentExport[];
+};
+
+/** A reference to an authored fact that already exists in the Linked Program. */
+type AuthorRecordRef = {
+    readonly kind: "record";
+    readonly id: string;
+};
+/** A symbolic reference to one public export of another component instance. */
+type AuthorComponentOutputRef = {
+    readonly kind: "component-output";
+    readonly component: string;
+    readonly output: string;
+};
+type AuthorValueRef = AuthorRecordRef | AuthorComponentOutputRef;
+/**
+ * One author-visible component call. `outputs` binds every public Fragment export to a Logical Output.
+ */
+type AuthorComponent = {
+    readonly id: string;
+    readonly fragment: string;
+    readonly inputs: Readonly<Record<string, AuthorValueRef>>;
+    readonly outputs: Readonly<Record<string, string>>;
+};
+
+type SourceHeader = {
+    /** Logical Frontend request. A trusted Host resolves it to one exact implementation. */
+    readonly using: string;
+    readonly start: number;
+    readonly end: number;
+};
+
+type SourceUnit = {
+    /** Host-canonical identity used only for recursion and diagnostics. */
+    readonly id: string;
+    readonly name: string;
+    readonly text: string;
+};
+type SourceImportRequest = {
+    readonly from: string;
+    readonly alias: string;
+    readonly range?: SourceRange;
+};
+type SourceAssetRequest = {
+    readonly from: string;
+    readonly mediaType: string;
+    /** Package-owned bytes admitted by the compiler before a Workspace is consulted. */
+    readonly bytes?: Uint8Array;
+    readonly range?: SourceRange;
+};
+type ResolvedSourceAsset = {
+    readonly artifact: BlobRef;
+};
+
+type AuthorSourceUnit = SourceUnit;
+/** Source presented to a Frontend after the mandatory Header has been admitted and masked. */
+type AuthorFrontendSourceUnit = AuthorSourceUnit & {
+    readonly header: SourceHeader;
+};
+type AuthorSourceImport = SourceImportRequest;
+type AuthorSourceDiscovery = {
+    readonly modules: readonly string[];
+    readonly sources: readonly AuthorSourceImport[];
+};
+/** A semantic source dependency requested by a Frontend or package-owned Surface. */
+type AuthorSourceAssetRequest = SourceAssetRequest;
+type ResolvedAuthorSourceAsset = ResolvedSourceAsset;
+type AuthorSourceExport = {
+    /** Relative public name. The importing source contributes its own alias. */
+    readonly name: string;
+    readonly ref: AuthorValueRef;
+    readonly type: TypeRef;
+};
+/**
+ * One author-visible identity whose uniqueness is part of a domain's public
+ * contract. The Frontend only carries the declaration; the owning Surface
+ * chooses the Type namespace and the Source closure enforces it generically.
+ */
+type AuthorSourceIdentity = {
+    readonly namespace: TypeRef;
+    readonly id: string;
+};
+/** One author input before Source-local graph identities are hygienized. */
+type AuthorInputProvenanceDraft = {
+    readonly name: string;
+    readonly range: SourceRange;
+    readonly kind: "literal" | "reference";
+    readonly ref?: AuthorValueRef;
+};
+/**
+ * Structural origin retained by a Frontend while it lowers author syntax.
+ * It contains no editor presentation and is never persisted beside the Source.
+ */
+type AuthorElementProvenanceDraft = {
+    readonly range: SourceRange;
+    readonly records: readonly string[];
+    readonly components: readonly string[];
+    readonly outputs: readonly {
+        readonly component: string;
+        readonly name: string;
+        readonly id: string;
+    }[];
+    readonly inputs: readonly AuthorInputProvenanceDraft[];
+};
+type ResolvedAuthorSourceImport = {
+    readonly request: AuthorSourceImport;
+    readonly source: string;
+    readonly exports: readonly AuthorSourceExport[];
+    /** Public record exports available to a package-owned Surface during author compilation. */
+    readonly records: readonly TypedRecord[];
+};
+type AuthorSourceDecodeContext = {
+    readonly closure: ResolvedModuleClosure;
+    readonly imports: readonly ResolvedAuthorSourceImport[];
+    /** Host authority: Frontends declare asset dependencies but never open files themselves. */
+    readonly resolveAsset: (request: AuthorSourceAssetRequest) => Awaitable<ResolvedAuthorSourceAsset>;
+};
+type DecodedAuthorSource = {
+    readonly records: readonly TypedRecord[];
+    readonly components: readonly AuthorComponent[];
+    readonly fragments: readonly GraphFragment[];
+    readonly exports: readonly AuthorSourceExport[];
+    readonly identities?: readonly AuthorSourceIdentity[];
+    readonly provenance?: readonly AuthorElementProvenanceDraft[];
+};
+type Awaitable<T> = T | Promise<T>;
+type AuthorFrontend = {
+    readonly id: string;
+    discover(source: AuthorFrontendSourceUnit): Awaitable<AuthorSourceDiscovery>;
+    decode(source: AuthorFrontendSourceUnit, context: AuthorSourceDecodeContext): Awaitable<DecodedAuthorSource>;
+};
+
+declare const textSvsFrontendId = "@hypit/text/svs@1";
+declare const textSvsFrontend: AuthorFrontend;
+
+type TextFragmentBinding = {
+    readonly name: string;
+};
+/**
+ * A reusable graph shape for Template + initial Bindings + explicit Text edges.
+ * The caller supplies one authored TextBinding record and one Text value for
+ * every entry; no binding is discovered through metadata.
+ */
+declare function createTextRenderFragment(entries?: readonly TextFragmentBinding[]): GraphFragment;
+
+declare const textModuleRef: {
+    readonly name: "@hypit/text";
+    readonly version: "1";
+};
+declare const textTypes: {
+    text: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    template: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    bindings: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    binding: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+};
+declare const textProducers: {
+    emptyBindings: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    bindText: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    render: {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    };
+};
+declare const textMarkupSurfaces: readonly [{
+    readonly name: "value";
+    readonly tag: "Value";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Authors one literal Text value from the element's own body.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the Text Record this element publishes.";
+        }];
+        readonly text: "The element's body is the exact Text value, with the blank lines around it and the indentation shared by every line removed.";
+        readonly example: "<text:Value id=\"extra\">Keep the product readable.</text:Value>";
+        readonly notes: readonly ["The element accepts text only; a child element is refused.", "The Text is published under the bare `id`."];
+    };
+}, {
+    readonly name: "render";
+    readonly tag: "Render";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/text";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Renders one TextTemplate against explicit bindings and publishes the result as an ordinary Text graph value.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the render, under which the rendered Text and its binding Records are published.";
+        }, {
+            readonly name: "template";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/text";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "Chooses the TextTemplate that is rendered.";
+            readonly recipe: readonly [{
+                readonly name: "separator";
+                readonly required: false;
+                readonly values: readonly ["paragraph"];
+                readonly fallback: "paragraph";
+                readonly summary: "Decides how the root Recipe joins its blocks, which is by one blank line.";
+            }, {
+                readonly name: "default-<binding>";
+                readonly required: false;
+                readonly summary: "Fills the binding of that name from the root Recipe whenever a render supplies nothing for it.";
+            }, {
+                readonly name: "kind";
+                readonly required: true;
+                readonly values: readonly ["fixed", "axis", "variant", "slot"];
+                readonly summary: "Decides what a block Recipe contributes: literal Text, a choice keyed by one binding, a choice keyed by conditions, or a binding rendered in place.";
+            }, {
+                readonly name: "order";
+                readonly required: true;
+                readonly summary: "Places a block among the Template's blocks as a non-negative integer no other block repeats.";
+            }, {
+                readonly name: "text";
+                readonly required: true;
+                readonly summary: "Carries the literal Text a `fixed` block, or one choice of an `axis` or `variant` block, contributes.";
+            }, {
+                readonly name: "parameter";
+                readonly required: true;
+                readonly summary: "Names the binding an `axis` block reads, whose value picks the choice carrying that id.";
+            }, {
+                readonly name: "slot";
+                readonly required: true;
+                readonly summary: "Names the binding a `slot` block renders in place.";
+            }, {
+                readonly name: "optional";
+                readonly required: false;
+                readonly fallback: "false";
+                readonly summary: "Decides whether a `slot` block is left out entirely when its binding is absent.";
+            }, {
+                readonly name: "label";
+                readonly required: false;
+                readonly summary: "Puts one line of literal Text above the binding a `slot` block renders.";
+            }, {
+                readonly name: "when-param-<binding>";
+                readonly required: false;
+                readonly summary: "Holds a `variant` choice back until the binding of that name equals this scalar.";
+            }, {
+                readonly name: "when-select-<binding>";
+                readonly required: false;
+                readonly summary: "States the same condition as `when-param-`, for a binding an author reads as a Selection.";
+            }];
+        }, {
+            readonly name: "recipe";
+            readonly kind: "reference";
+            readonly required: false;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/svs";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "Chooses the Recipe whose scalar properties fill the bindings the Template declares.";
+        }];
+        readonly children: readonly [{
+            readonly tag: "Param";
+            readonly cardinality: "many";
+            readonly summary: "Writes one scalar binding literally, in place of the Recipe property of that name.";
+            readonly attributes: readonly [{
+                readonly name: "name";
+                readonly kind: "literal";
+                readonly required: true;
+                readonly summary: "Names the binding this scalar fills.";
+            }, {
+                readonly name: "value";
+                readonly kind: "literal";
+                readonly required: true;
+                readonly summary: "Carries the scalar the binding takes, read as the declared type.";
+            }, {
+                readonly name: "type";
+                readonly kind: "literal";
+                readonly required: false;
+                readonly values: readonly ["text", "number", "boolean"];
+                readonly summary: "Chooses how `value` is read, defaulting to text.";
+            }];
+        }, {
+            readonly tag: "Set";
+            readonly cardinality: "many";
+            readonly summary: "Connects one Text as a graph edge that replaces the binding of that name.";
+            readonly attributes: readonly [{
+                readonly name: "name";
+                readonly kind: "literal";
+                readonly required: true;
+                readonly summary: "Names the binding this Text replaces.";
+            }, {
+                readonly name: "text";
+                readonly kind: "reference";
+                readonly required: true;
+                readonly accepts: readonly [{
+                    module: {
+                        readonly name: "@hypit/text";
+                        readonly version: "1";
+                    };
+                    name: string;
+                }];
+                readonly summary: "Selects the Text the binding takes.";
+            }];
+        }, {
+            readonly tag: "Append";
+            readonly cardinality: "many";
+            readonly summary: "Connects one Text as a graph edge that is added after the binding of that name.";
+            readonly attributes: readonly [{
+                readonly name: "name";
+                readonly kind: "literal";
+                readonly required: true;
+                readonly summary: "Names the binding this Text is added after.";
+            }, {
+                readonly name: "text";
+                readonly kind: "reference";
+                readonly required: true;
+                readonly accepts: readonly [{
+                    module: {
+                        readonly name: "@hypit/text";
+                        readonly version: "1";
+                    };
+                    name: string;
+                }];
+                readonly summary: "Selects the Text added after the binding.";
+            }];
+        }];
+        readonly ports: readonly [{
+            readonly name: "";
+            readonly type: {
+                module: {
+                    readonly name: "@hypit/text";
+                    readonly version: "1";
+                };
+                name: string;
+            };
+            readonly summary: "The rendered Text, addressed by the element's own id.";
+        }];
+        readonly example: "<text:Render id=\"prompt\" template={ugc.product-shot} recipe={recipes.product-shot}>\n  <text:Param name=\"camera\" value=\"handheld\"/>\n  <text:Param name=\"strict\" value=\"true\" type=\"boolean\"/>\n  <text:Set name=\"dialogue\" text={story.segment.hook.dialogue}/>\n  <text:Append name=\"constraints\" text={extra}/>\n</text:Render>";
+        readonly notes: readonly ["Two `Param` children may not carry the same name; `Set` and `Append` children apply in the order written.", "`recipe` fills only the bindings the Template declares; every other Recipe property is ignored, and a `Param` of the same name wins over it.", "A TextTemplate sheet declares exactly one root Recipe `text-template.<id>`, its blocks under `<root>.block.<block>` and their choices under `<root>.choice.<block>.<choice>`; any other Recipe beneath the root is refused.", "Each of those Recipes accepts exactly the properties its kind allows and refuses every other one; a `fixed` block takes `text`, an `axis` block takes `parameter`, a `variant` block takes neither, and a `slot` block takes `slot`, `optional` and `label`.", "The initial bindings are sealed into a TextBindings Record published as `<id>.bindings`, and each Set or Append spec into its own TextBinding Record.", "The element carries no text content of its own."];
+    };
+}];
+declare const textManifest: ModuleManifest;
+declare const textDependency: {
+    readonly module: {
+        readonly name: "@hypit/text";
+        readonly version: "1";
+    };
+};
+
+declare function verifyText(value: unknown): asserts value is Text;
+declare function sealText(value: string): Text;
+declare function verifyTextBindings(value: unknown): asserts value is TextBindings;
+declare function sealTextBindings(values?: Readonly<Record<string, TextBindingValue>>): TextBindings;
+declare function verifyTextBinding(value: unknown): asserts value is TextBinding;
+declare function sealTextBinding(value: TextBinding): TextBinding;
+declare function bindText(bindings: TextBindings, binding: TextBinding, text: Text): TextBindings;
+declare function verifyTextTemplate(value: unknown): asserts value is TextTemplate;
+declare function sealTextTemplate(value: TextTemplate): TextTemplate;
+declare function textTemplateBindingNames(template: TextTemplate): ReadonlySet<string>;
+declare function renderText(template: TextTemplate, bindings: TextBindings): Text;
+
+type SvsRecipe = {
+    readonly path: string;
+    readonly properties: Readonly<Record<string, CanonicalValue>>;
+};
+
+/**
+ * One optional textual convention for authoring a TextTemplate in flat SVS.
+ * SVS remains inert data; this Frontend only lowers fixed/axis/variant/slot
+ * recipes into the ordinary domain-neutral Text expression language.
+ */
+declare function textTemplateFromSvsRecipes(recipes: readonly SvsRecipe[], templateId: string): TextTemplate;
+
+type MarkupReference = {
+    readonly kind: "reference";
+    readonly path: string;
+};
+type MarkupAttributeValue = string | MarkupReference;
+type StructuredText = {
+    readonly kind: "text";
+    readonly value: string;
+    readonly range: SourceRange;
+};
+type StructuredElement = {
+    readonly kind: "element";
+    readonly name: string;
+    readonly attributes: Readonly<Record<string, MarkupAttributeValue>>;
+    /** Exact ranges of literal/reference values in the opening tag. */
+    readonly attributeValueRanges?: Readonly<Record<string, SourceRange>>;
+    readonly children: readonly StructuredNode[];
+    readonly range: SourceRange;
+};
+type StructuredNode = StructuredText | StructuredElement;
+type SurfaceRecordDraft = {
+    readonly id: string;
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+    readonly range: SourceRange;
+};
+/** Source-local diagnostics are removed before the component enters semantic elaboration. */
+type SurfaceComponentDraft = AuthorComponent & {
+    readonly range: SourceRange;
+};
+type SurfaceDecodeOutput = {
+    readonly records: readonly SurfaceRecordDraft[];
+    readonly components: readonly SurfaceComponentDraft[];
+    readonly fragments: readonly GraphFragment[];
+    /** Domain-owned public identities that must be unique in the Source closure. */
+    readonly identities?: readonly AuthorSourceIdentity[];
+    /**
+     * Public source bindings contributed by this Surface invocation. Omit to
+     * publish every generated binding; use an explicit list to keep plumbing
+     * addressable inside the source without exposing it from the source.
+     */
+    readonly exports?: readonly string[];
+};
+type StructuredSurfaceInput = {
+    readonly sourceName: string;
+    readonly element: StructuredElement;
+    /**
+     * Resolve an explicitly written author reference. Imported record values are
+     * available because their source has already been compiled and admitted.
+     * A component output has a ref and Type but no compile-time Record value.
+     */
+    readonly resolveReference: (path: string) => SurfaceResolvedReference | undefined;
+    readonly resolveAsset: (request: AuthorSourceAssetRequest) => Awaitable<ResolvedAuthorSourceAsset>;
+};
+type SurfaceResolvedReference = {
+    readonly path: string;
+    readonly ref: AuthorValueRef;
+    readonly type: TypeRef;
+    readonly record?: TypedRecord;
+};
+type StructuredSurfaceHandler = (input: StructuredSurfaceInput) => Awaitable<SurfaceDecodeOutput>;
+
+/** Author one literal graph Text value. */
+declare const decodeTextValueSurface: StructuredSurfaceHandler;
+/**
+ * Render one TextTemplate. Param children author scalar bindings; Set/Append
+ * children attach ordinary Text graph edges in source order.
+ */
+declare const decodeTextRenderSurface: StructuredSurfaceHandler;
+
+export { bindText, createTextRenderFragment, decodeTextRenderSurface, decodeTextValueSurface, renderText, sealText, sealTextBinding, sealTextBindings, sealTextTemplate, textComponent, textDependency, textManifest, textMarkupSurfaces, textModuleRef, textProducers, textSvsFrontend, textSvsFrontendId, textTemplateBindingNames, textTemplateFromSvsRecipes, textTypes, verifyText, verifyTextBinding, verifyTextBindings, verifyTextTemplate };
+export type { Text, TextBinding, TextBindingValue, TextBindings, TextCondition, TextExpression, TextFragmentBinding, TextScalar, TextTemplate, TextTransform };