@llui/vite-plugin 0.0.28 → 0.0.29

package/dist/msg-annotations.js

@@ -0,0 +1,91 @@
+import ts from 'typescript';
+const DEFAULT = {
+    intent: null,
+    alwaysAffordable: false,
+    requiresConfirm: false,
+    humanOnly: false,
+};
+/**
+ * Walk a Msg-like discriminated-union type alias and extract JSDoc
+ * annotations attached to each union member. Returns null if no
+ * recognizable union is found so callers can skip emission cleanly.
+ *
+ * Expected JSDoc grammar (order-independent):
+ *   @intent("human readable")
+ *   @alwaysAffordable
+ *   @requiresConfirm
+ *   @humanOnly
+ *
+ * Unknown tags are ignored; malformed @intent (no quoted string) is
+ * treated as "no intent". The four flags are booleans; any occurrence
+ * of the tag sets it true.
+ */
+export function extractMsgAnnotations(source) {
+    const sf = ts.createSourceFile('msg.ts', source, ts.ScriptTarget.Latest, true);
+    const aliases = [];
+    sf.forEachChild((n) => {
+        if (ts.isTypeAliasDeclaration(n))
+            aliases.push(n);
+    });
+    const named = aliases.find((a) => a.name.text === 'Msg');
+    const alias = named ?? aliases.find((a) => ts.isUnionTypeNode(a.type));
+    if (!alias || !ts.isUnionTypeNode(alias.type))
+        return null;
+    const result = {};
+    const types = alias.type.types;
+    for (let i = 0; i < types.length; i++) {
+        const member = types[i];
+        if (member === undefined || !ts.isTypeLiteralNode(member))
+            continue;
+        const variant = readDiscriminantLiteral(member);
+        if (!variant)
+            continue;
+        // Leading JSDoc for union member i is scanned from the end of the
+        // previous element (or union.pos for the first member), because
+        // TypeScript's parser places comment ranges relative to the token
+        // that follows them — and the | bar is not part of the TypeLiteralNode.
+        const prev = types[i - 1];
+        const scanPos = i === 0 || prev === undefined ? alias.type.pos : prev.end;
+        const comment = readLeadingJSDoc(source, scanPos);
+        result[variant] = parseAnnotations(comment);
+    }
+    return Object.keys(result).length === 0 ? null : result;
+}
+function readDiscriminantLiteral(lit) {
+    for (const m of lit.members) {
+        if (!ts.isPropertySignature(m))
+            continue;
+        if (!m.name || !ts.isIdentifier(m.name) || m.name.text !== 'type')
+            continue;
+        if (!m.type || !ts.isLiteralTypeNode(m.type))
+            continue;
+        const literal = m.type.literal;
+        if (ts.isStringLiteral(literal))
+            return literal.text;
+    }
+    return null;
+}
+function readLeadingJSDoc(source, scanPos) {
+    const ranges = ts.getLeadingCommentRanges(source, scanPos) ?? [];
+    const docs = ranges
+        .filter((r) => r.kind === ts.SyntaxKind.MultiLineCommentTrivia)
+        .map((r) => source.slice(r.pos, r.end))
+        .filter((txt) => txt.startsWith('/**'));
+    return docs.join('\n');
+}
+function parseAnnotations(comment) {
+    if (!comment)
+        return { ...DEFAULT };
+    const intent = readIntent(comment);
+    return {
+        intent,
+        alwaysAffordable: /@alwaysAffordable\b/.test(comment),
+        requiresConfirm: /@requiresConfirm\b/.test(comment),
+        humanOnly: /@humanOnly\b/.test(comment),
+    };
+}
+function readIntent(comment) {
+    const match = comment.match(/@intent\s*\(\s*["\u201c]([^"\u201d]*)["\u201d]\s*\)/);
+    return match?.[1] ?? null;
+}
+//# sourceMappingURL=msg-annotations.js.map

package/dist/msg-annotations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg-annotations.js","sourceRoot":"","sources":["../src/msg-annotations.ts"],"names":[],"mappings":"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","sourcesContent":["import ts from 'typescript'\n\nexport type MessageAnnotations = {\n  intent: string | null\n  alwaysAffordable: boolean\n  requiresConfirm: boolean\n  humanOnly: boolean\n}\n\nconst DEFAULT: MessageAnnotations = {\n  intent: null,\n  alwaysAffordable: false,\n  requiresConfirm: false,\n  humanOnly: false,\n}\n\n/**\n * Walk a Msg-like discriminated-union type alias and extract JSDoc\n * annotations attached to each union member. Returns null if no\n * recognizable union is found so callers can skip emission cleanly.\n *\n * Expected JSDoc grammar (order-independent):\n *   @intent(\"human readable\")\n *   @alwaysAffordable\n *   @requiresConfirm\n *   @humanOnly\n *\n * Unknown tags are ignored; malformed @intent (no quoted string) is\n * treated as \"no intent\". The four flags are booleans; any occurrence\n * of the tag sets it true.\n */\nexport function extractMsgAnnotations(source: string): Record<string, MessageAnnotations> | null {\n  const sf = ts.createSourceFile('msg.ts', source, ts.ScriptTarget.Latest, true)\n  const aliases: ts.TypeAliasDeclaration[] = []\n  sf.forEachChild((n) => {\n    if (ts.isTypeAliasDeclaration(n)) aliases.push(n)\n  })\n  const named = aliases.find((a) => a.name.text === 'Msg')\n  const alias = named ?? aliases.find((a) => ts.isUnionTypeNode(a.type))\n  if (!alias || !ts.isUnionTypeNode(alias.type)) return null\n\n  const result: Record<string, MessageAnnotations> = {}\n  const types = alias.type.types\n  for (let i = 0; i < types.length; i++) {\n    const member = types[i]\n    if (member === undefined || !ts.isTypeLiteralNode(member)) continue\n    const variant = readDiscriminantLiteral(member)\n    if (!variant) continue\n    // Leading JSDoc for union member i is scanned from the end of the\n    // previous element (or union.pos for the first member), because\n    // TypeScript's parser places comment ranges relative to the token\n    // that follows them — and the | bar is not part of the TypeLiteralNode.\n    const prev = types[i - 1]\n    const scanPos = i === 0 || prev === undefined ? alias.type.pos : prev.end\n    const comment = readLeadingJSDoc(source, scanPos)\n    result[variant] = parseAnnotations(comment)\n  }\n  return Object.keys(result).length === 0 ? null : result\n}\n\nfunction readDiscriminantLiteral(lit: ts.TypeLiteralNode): string | null {\n  for (const m of lit.members) {\n    if (!ts.isPropertySignature(m)) continue\n    if (!m.name || !ts.isIdentifier(m.name) || m.name.text !== 'type') continue\n    if (!m.type || !ts.isLiteralTypeNode(m.type)) continue\n    const literal = m.type.literal\n    if (ts.isStringLiteral(literal)) return literal.text\n  }\n  return null\n}\n\nfunction readLeadingJSDoc(source: string, scanPos: number): string {\n  const ranges = ts.getLeadingCommentRanges(source, scanPos) ?? []\n  const docs = ranges\n    .filter((r) => r.kind === ts.SyntaxKind.MultiLineCommentTrivia)\n    .map((r) => source.slice(r.pos, r.end))\n    .filter((txt) => txt.startsWith('/**'))\n  return docs.join('\\n')\n}\n\nfunction parseAnnotations(comment: string): MessageAnnotations {\n  if (!comment) return { ...DEFAULT }\n  const intent = readIntent(comment)\n  return {\n    intent,\n    alwaysAffordable: /@alwaysAffordable\\b/.test(comment),\n    requiresConfirm: /@requiresConfirm\\b/.test(comment),\n    humanOnly: /@humanOnly\\b/.test(comment),\n  }\n}\n\nfunction readIntent(comment: string): string | null {\n  const match = comment.match(/@intent\\s*\\(\\s*[\"\\u201c]([^\"\\u201d]*)[\"\\u201d]\\s*\\)/)\n  return match?.[1] ?? null\n}\n"]}

package/dist/schema-hash.d.ts

@@ -0,0 +1,16 @@
+import type { MessageAnnotations } from './msg-annotations.js';
+export type SchemaHashInput = {
+    msgSchema: unknown;
+    stateSchema: unknown;
+    msgAnnotations: Record<string, MessageAnnotations> | null | undefined;
+};
+/**
+ * Stable hex SHA-256 (first 32 chars) over a normalized JSON serialization
+ * of msgSchema + stateSchema + msgAnnotations. Object key order is
+ * normalized so equivalent inputs always produce equal hashes.
+ *
+ * Used by the runtime to detect when the browser-to-server `hello` frame
+ * needs to re-send its schema payload (dev hot-reload).
+ */
+export declare function computeSchemaHash(input: SchemaHashInput): string;
+//# sourceMappingURL=schema-hash.d.ts.map

package/dist/schema-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-hash.d.ts","sourceRoot":"","sources":["../src/schema-hash.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,OAAO,CAAA;IACpB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAAG,IAAI,GAAG,SAAS,CAAA;CACtE,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAQhE"}

package/dist/schema-hash.js

@@ -0,0 +1,31 @@
+import { createHash } from 'node:crypto';
+/**
+ * Stable hex SHA-256 (first 32 chars) over a normalized JSON serialization
+ * of msgSchema + stateSchema + msgAnnotations. Object key order is
+ * normalized so equivalent inputs always produce equal hashes.
+ *
+ * Used by the runtime to detect when the browser-to-server `hello` frame
+ * needs to re-send its schema payload (dev hot-reload).
+ */
+export function computeSchemaHash(input) {
+    const normalized = {
+        msgSchema: sortDeep(input.msgSchema),
+        stateSchema: sortDeep(input.stateSchema),
+        msgAnnotations: sortDeep(input.msgAnnotations ?? null),
+    };
+    const json = JSON.stringify(normalized);
+    return createHash('sha256').update(json).digest('hex').slice(0, 32);
+}
+function sortDeep(value) {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map(sortDeep);
+    const obj = value;
+    const out = {};
+    for (const k of Object.keys(obj).sort()) {
+        out[k] = sortDeep(obj[k]);
+    }
+    return out;
+}
+//# sourceMappingURL=schema-hash.js.map

package/dist/schema-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-hash.js","sourceRoot":"","sources":["../src/schema-hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AASxC;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAsB;IACtD,MAAM,UAAU,GAAG;QACjB,SAAS,EAAE,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC;QACpC,WAAW,EAAE,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC;QACxC,cAAc,EAAE,QAAQ,CAAC,KAAK,CAAC,cAAc,IAAI,IAAI,CAAC;KACvD,CAAA;IACD,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;IACvC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;AACrE,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAC7D,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IACpD,MAAM,GAAG,GAAG,KAAgC,CAAA;IAC5C,MAAM,GAAG,GAA4B,EAAE,CAAA;IACvC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACxC,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAA;IAC3B,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC","sourcesContent":["import { createHash } from 'node:crypto'\nimport type { MessageAnnotations } from './msg-annotations.js'\n\nexport type SchemaHashInput = {\n  msgSchema: unknown\n  stateSchema: unknown\n  msgAnnotations: Record<string, MessageAnnotations> | null | undefined\n}\n\n/**\n * Stable hex SHA-256 (first 32 chars) over a normalized JSON serialization\n * of msgSchema + stateSchema + msgAnnotations. Object key order is\n * normalized so equivalent inputs always produce equal hashes.\n *\n * Used by the runtime to detect when the browser-to-server `hello` frame\n * needs to re-send its schema payload (dev hot-reload).\n */\nexport function computeSchemaHash(input: SchemaHashInput): string {\n  const normalized = {\n    msgSchema: sortDeep(input.msgSchema),\n    stateSchema: sortDeep(input.stateSchema),\n    msgAnnotations: sortDeep(input.msgAnnotations ?? null),\n  }\n  const json = JSON.stringify(normalized)\n  return createHash('sha256').update(json).digest('hex').slice(0, 32)\n}\n\nfunction sortDeep(value: unknown): unknown {\n  if (value === null || typeof value !== 'object') return value\n  if (Array.isArray(value)) return value.map(sortDeep)\n  const obj = value as Record<string, unknown>\n  const out: Record<string, unknown> = {}\n  for (const k of Object.keys(obj).sort()) {\n    out[k] = sortDeep(obj[k])\n  }\n  return out\n}\n"]}

package/dist/transform.d.ts

@@ -7,7 +7,7 @@ export interface TransformEdit {
     end: number;
     replacement: string;
 }
-export declare function transformLlui(source: string, _filename: string, devMode?: boolean, mcpPort?: number | null, verbose?: boolean): {
+export declare function transformLlui(source: string, _filename: string, devMode?: boolean, emitAgentMetadata?: boolean, mcpPort?: number | null, verbose?: boolean): {
     output: string;
     edits: TransformEdit[];
 } | null;

package/dist/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AA6KA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,UAAQ,EACf,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,OAAO,UAAQ,GACd;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAAI,CAuQnD;AA++HD,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAoGjC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA4B7D"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAgLA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,UAAQ,EACf,iBAAiB,UAAQ,EACzB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,OAAO,UAAQ,GACd;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAAI,CAiSnD;AAwoID,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAoGjC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA4B7D"}

package/dist/transform.js

@@ -1,7 +1,10 @@
 import ts from 'typescript';
 import { collectDeps } from './collect-deps.js';
 import { extractMsgSchema, extractEffectSchema } from './msg-schema.js';
+import { extractMsgAnnotations } from './msg-annotations.js';
 import { extractStateSchema } from './state-schema.js';
+import { computeSchemaHash } from './schema-hash.js';
+import { extractBindingDescriptors } from './binding-descriptors.js';
 function createMaskLiteral(f, mask) {
     if (mask >= 0)
         return f.createNumericLiteral(mask);
@@ -172,7 +175,7 @@ function resolveKey(key, kind) {
         return 'class';
     return key;
 }
-export function transformLlui(source, _filename, devMode = false, mcpPort = 5200, verbose = false) {
+export function transformLlui(source, _filename, devMode = false, emitAgentMetadata = false, mcpPort = 5200, verbose = false) {
     const sourceFile = ts.createSourceFile('input.ts', source, ts.ScriptTarget.Latest, true);
     // Find the @llui/dom import
     const imp = findLluiImport(sourceFile);
@@ -296,12 +299,20 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
             let result = tryInjectDirty(node, fieldBits, f);
             if (result)
                 usesApplyBinding = true;
-            if (devMode) {
-                const schema = extractMsgSchema(source);
-                if (schema) {
-                    result = injectMsgSchema(result ?? node, schema, f);
+            // Extract schema data once — used both for devMode injections and the
+            // unconditional __schemaHash (spec §7.4: hash ships in prod too).
+            const msgSchema = extractMsgSchema(source);
+            const msgAnnotations = extractMsgAnnotations(source);
+            const stateSchema = extractStateSchema(source);
+            const bindingDescriptors = extractBindingDescriptors(source);
+            const shouldEmitAgentMetadata = devMode || emitAgentMetadata;
+            if (shouldEmitAgentMetadata) {
+                if (msgSchema) {
+                    result = injectMsgSchema(result ?? node, msgSchema, f);
+                }
+                if (msgAnnotations && hasNonDefaultAnnotation(msgAnnotations)) {
+                    result = injectMsgAnnotations(result ?? node, msgAnnotations, f);
                 }
-                const stateSchema = extractStateSchema(source);
                 if (stateSchema) {
                     result = injectStateSchema(result ?? node, stateSchema.fields, f);
                 }
@@ -309,8 +320,21 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
                 if (effectSchema) {
                     result = injectEffectSchema(result ?? node, effectSchema, f);
                 }
+                if (bindingDescriptors.length > 0) {
+                    result = injectBindingDescriptors(result ?? node, bindingDescriptors, f);
+                }
+            }
+            if (devMode) {
                 result = injectComponentMeta(result ?? node, node, sourceFile, _filename, f);
             }
+            // __schemaHash is always emitted (not dev-gated) — runtime uses it to
+            // gate hello-frame re-sends during hot-reload in prod builds too.
+            const schemaHash = computeSchemaHash({
+                msgSchema: msgSchema ?? null,
+                stateSchema: stateSchema ?? null,
+                msgAnnotations,
+            });
+            result = injectSchemaHash(result ?? node, schemaHash, f);
             if (result) {
                 if (hasPos)
                     edits.push({ start: origStart, end: origEnd, replacement: '' });
@@ -2124,6 +2148,71 @@ function injectMsgSchema(node, schema, f) {
         ...node.arguments.slice(1),
     ]);
 }
+function hasNonDefaultAnnotation(a) {
+    for (const v of Object.values(a)) {
+        if (v.intent !== null)
+            return true;
+        if (v.alwaysAffordable)
+            return true;
+        if (v.requiresConfirm)
+            return true;
+        if (v.humanOnly)
+            return true;
+    }
+    return false;
+}
+function annotationsToObjectLiteral(a) {
+    const props = [];
+    for (const [variant, ann] of Object.entries(a)) {
+        props.push(ts.factory.createPropertyAssignment(variant, ts.factory.createObjectLiteralExpression([
+            ts.factory.createPropertyAssignment('intent', ann.intent === null
+                ? ts.factory.createNull()
+                : ts.factory.createStringLiteral(ann.intent)),
+            ts.factory.createPropertyAssignment('alwaysAffordable', ann.alwaysAffordable ? ts.factory.createTrue() : ts.factory.createFalse()),
+            ts.factory.createPropertyAssignment('requiresConfirm', ann.requiresConfirm ? ts.factory.createTrue() : ts.factory.createFalse()),
+            ts.factory.createPropertyAssignment('humanOnly', ann.humanOnly ? ts.factory.createTrue() : ts.factory.createFalse()),
+        ], true)));
+    }
+    return ts.factory.createObjectLiteralExpression(props, true);
+}
+function injectMsgAnnotations(node, annotations, f) {
+    const configArg = node.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg))
+        return node;
+    // Don't inject if already present
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === '__msgAnnotations') {
+            return node;
+        }
+    }
+    const annotationsProp = f.createPropertyAssignment('__msgAnnotations', annotationsToObjectLiteral(annotations));
+    const newConfig = f.createObjectLiteralExpression([...configArg.properties, annotationsProp], true);
+    return f.createCallExpression(node.expression, node.typeArguments, [
+        newConfig,
+        ...node.arguments.slice(1),
+    ]);
+}
+function injectSchemaHash(node, hash, f) {
+    const configArg = node.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg))
+        return node;
+    // Don't inject if already present
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === '__schemaHash') {
+            return node;
+        }
+    }
+    const hashProp = f.createPropertyAssignment('__schemaHash', f.createStringLiteral(hash));
+    const newConfig = f.createObjectLiteralExpression([...configArg.properties, hashProp], true);
+    return f.createCallExpression(node.expression, node.typeArguments, [
+        newConfig,
+        ...node.arguments.slice(1),
+    ]);
+}
 function injectEffectSchema(node, schema, f) {
     const configArg = node.arguments[0];
     if (!configArg || !ts.isObjectLiteralExpression(configArg))
@@ -2161,6 +2250,29 @@ function injectEffectSchema(node, schema, f) {
         ...node.arguments.slice(1),
     ]);
 }
+function injectBindingDescriptors(node, descs, f) {
+    const configArg = node.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg))
+        return node;
+    // Don't inject if already present
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === '__bindingDescriptors') {
+            return node;
+        }
+    }
+    const descsProp = f.createPropertyAssignment('__bindingDescriptors', bindingDescriptorsToArrayLiteral(descs));
+    const newConfig = f.createObjectLiteralExpression([...configArg.properties, descsProp], true);
+    return f.createCallExpression(node.expression, node.typeArguments, [
+        newConfig,
+        ...node.arguments.slice(1),
+    ]);
+}
+function bindingDescriptorsToArrayLiteral(descs) {
+    const entries = descs.map((d) => ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment('variant', ts.factory.createStringLiteral(d.variant))], false));
+    return ts.factory.createArrayLiteralExpression(entries, true);
+}
 // ── Per-item accessor detection ──────────────────────────────────
 // ── Item selector deduplication ──────────────────────────────────
 /**