@llui/vite-plugin 0.0.28 → 0.0.30

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":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAS3B,MAAM,OAAO,GAAuB;IAClC,MAAM,EAAE,IAAI;IACZ,gBAAgB,EAAE,KAAK;IACvB,eAAe,EAAE,KAAK;IACtB,SAAS,EAAE,KAAK;CACjB,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAc;IAClD,MAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAC9E,MAAM,OAAO,GAA8B,EAAE,CAAA;IAC7C,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,EAAE;QACpB,IAAI,EAAE,CAAC,sBAAsB,CAAC,CAAC,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IACnD,CAAC,CAAC,CAAA;IACF,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,CAAA;IACxD,MAAM,KAAK,GAAG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAA;IACtE,IAAI,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAA;IAE1D,MAAM,MAAM,GAAuC,EAAE,CAAA;IACrD,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAA;IAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACvB,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC;YAAE,SAAQ;QACnE,MAAM,OAAO,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAA;QAC/C,IAAI,CAAC,OAAO;YAAE,SAAQ;QACtB,kEAAkE;QAClE,gEAAgE;QAChE,kEAAkE;QAClE,wEAAwE;QACxE,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAA;QACzB,MAAM,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAA;QACzE,MAAM,OAAO,GAAG,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjD,MAAM,CAAC,OAAO,CAAC,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAC7C,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAA;AACzD,CAAC;AAED,SAAS,uBAAuB,CAAC,GAAuB;IACtD,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,EAAE,CAAC,mBAAmB,CAAC,CAAC,CAAC;YAAE,SAAQ;QACxC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,SAAQ;QAC3E,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC;YAAE,SAAQ;QACtD,MAAM,OAAO,GAAG,CAAC,CAAC,IAAI,CAAC,OAAO,CAAA;QAC9B,IAAI,EAAE,CAAC,eAAe,CAAC,OAAO,CAAC;YAAE,OAAO,OAAO,CAAC,IAAI,CAAA;IACtD,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED,SAAS,gBAAgB,CAAC,MAAc,EAAE,OAAe;IACvD,MAAM,MAAM,GAAG,EAAE,CAAC,uBAAuB,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,EAAE,CAAA;IAChE,MAAM,IAAI,GAAG,MAAM;SAChB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,sBAAsB,CAAC;SAC9D,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;SACtC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;IACzC,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACxB,CAAC;AAED,SAAS,gBAAgB,CAAC,OAAe;IACvC,IAAI,CAAC,OAAO;QAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAA;IACnC,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;IAClC,OAAO;QACL,MAAM;QACN,gBAAgB,EAAE,qBAAqB,CAAC,IAAI,CAAC,OAAO,CAAC;QACrD,eAAe,EAAE,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC;QACnD,SAAS,EAAE,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC;KACxC,CAAA;AACH,CAAC;AAED,SAAS,UAAU,CAAC,OAAe;IACjC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAA;IAClF,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAA;AAC3B,CAAC","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

@@ -1,3 +1,4 @@
+import ts from 'typescript';
 /**
  * Transform a source file containing @llui/dom imports.
  * Returns the transformed source or null if no transformation needed.
@@ -7,7 +8,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;
@@ -47,4 +48,31 @@ export declare function transformUseClientSsr(source: string, _filename: string)
  * without parsing the whole file twice.
  */
 export declare function hasUseClientDirective(source: string): boolean;
+/**
+ * Extract the view function body (the value of the `view:` property) from
+ * a component() config object literal.  Uses a regex heuristic — good enough
+ * for round-tripping source for dev/agent tools.
+ */
+export declare function extractViewBody(code: string): string | null;
+/**
+ * Extract the component `name:` string literal from a component() call's
+ * first argument object literal in the source text.
+ */
+export declare function extractComponentNameFromConfig(node: ts.CallExpression): string | null;
+/**
+ * Generate Object.defineProperty calls for __preSource, __postSource,
+ * __msgMaskMap, and __bindingSources on a component variable.  These are
+ * non-enumerable so they don't appear in JSON.stringify(componentDef) but are
+ * visible to devtools.
+ */
+export declare function generateCompilerCacheProps(varName: string, componentName: string): string;
+/**
+ * After the full output string is assembled, update each cached component's
+ * postSource (extract view body from the transformed output), then append
+ * Object.defineProperty calls for all four compiler-cache properties.
+ */
+export declare function appendCompilerCacheProps(output: string, componentDecls: Array<{
+    varName: string;
+    componentName: string;
+}>): string;
 //# sourceMappingURL=transform.d.ts.map

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":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAiL3B;;;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,CA8TnD;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;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI3D;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,GAAG,IAAI,CAcrF;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CASzF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,GAChE,MAAM,CAYR"}

package/dist/transform.js

@@ -1,7 +1,11 @@
 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';
+import { compilerCache } from './compiler-cache.js';
 function createMaskLiteral(f, mask) {
     if (mask >= 0)
         return f.createNumericLiteral(mask);
@@ -172,7 +176,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 +300,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 +321,37 @@ 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);
+                }
+                // Populate compiler cache — preSource and msgMaskMap are known now;
+                // postSource is filled in after the full output is assembled.
+                const cachedComponentName = extractComponentNameFromConfig(node);
+                if (cachedComponentName) {
+                    const preSource = extractViewBody(source) ?? '';
+                    const msgMaskMap = {};
+                    for (const [path, bit] of fieldBits) {
+                        msgMaskMap[path] = bit;
+                    }
+                    compilerCache.set(cachedComponentName, {
+                        preSource,
+                        postSource: '',
+                        msgMaskMap,
+                        bindingSources: [],
+                    });
+                }
+            }
+            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: '' });
@@ -326,8 +367,8 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
     transformed = cleanupImports(transformed, lluiImport, importedHelpers, safeToRemove, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, usesCloneStaticTemplate, f);
     if (edits.length === 0)
         return null;
-    // Find component declarations for HMR
-    const componentDecls = devMode ? findComponentDeclarations(sourceFile, lluiImport) : [];
+    // Find component declarations for HMR and agent metadata
+    const componentDecls = devMode || emitAgentMetadata ? findComponentDeclarations(sourceFile, lluiImport) : [];
     // Build per-statement edits by comparing original vs transformed.
     // Only emit edits for statements that actually changed.
     // Untouched code keeps its original positions → accurate source maps.
@@ -347,7 +388,10 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
             const { top: _top, bottom: _bottom } = devMode
                 ? generateDevCode(componentDecls, mcpPort)
                 : { top: '', bottom: '' };
-            const output = (_top ? _top + '\n' : '') + printer.printFile(transformed) + (_bottom ? '\n' + _bottom : '');
+            let output = (_top ? _top + '\n' : '') + printer.printFile(transformed) + (_bottom ? '\n' + _bottom : '');
+            if (devMode || emitAgentMetadata) {
+                output = appendCompilerCacheProps(output, componentDecls);
+            }
             return { output, edits: [{ start: 0, end: source.length, replacement: output }] };
         }
         // Compare ignoring trailing semicolons and whitespace (printer adds them)
@@ -379,6 +423,13 @@ export function transformLlui(source, _filename, devMode = false, mcpPort = 5200
     for (const edit of sorted) {
         output = output.slice(0, edit.start) + edit.replacement + output.slice(edit.end);
     }
+    // After output is assembled, update postSource in cache and emit non-enumerable props
+    if ((devMode || emitAgentMetadata) && componentDecls.length > 0) {
+        const cacheProps = appendCompilerCacheProps(output, componentDecls);
+        if (cacheProps !== output) {
+            output = cacheProps;
+        }
+    }
     return { output, edits: finalEdits };
 }
 // ── HMR ──────────────────────────────────────────────────────────
@@ -2124,6 +2175,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 +2277,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 ──────────────────────────────────
 /**
@@ -3293,4 +3432,66 @@ export function hasUseClientDirective(source) {
     }
     return source.startsWith("'use client'", i) || source.startsWith('"use client"', i);
 }
+// ── Compiler cache helpers ────────────────────────────────────────
+/**
+ * Extract the view function body (the value of the `view:` property) from
+ * a component() config object literal.  Uses a regex heuristic — good enough
+ * for round-tripping source for dev/agent tools.
+ */
+export function extractViewBody(code) {
+    const match = /\bview\s*:\s*([\s\S]*?)(?=,\s*(?:onEffect|update|init|name|onMsg)\s*:|}\s*\))/m.exec(code);
+    return match?.[1]?.trim() ?? null;
+}
+/**
+ * Extract the component `name:` string literal from a component() call's
+ * first argument object literal in the source text.
+ */
+export function extractComponentNameFromConfig(node) {
+    const configArg = node.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg))
+        return null;
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'name' &&
+            ts.isStringLiteral(prop.initializer)) {
+            return prop.initializer.text;
+        }
+    }
+    return null;
+}
+/**
+ * Generate Object.defineProperty calls for __preSource, __postSource,
+ * __msgMaskMap, and __bindingSources on a component variable.  These are
+ * non-enumerable so they don't appear in JSON.stringify(componentDef) but are
+ * visible to devtools.
+ */
+export function generateCompilerCacheProps(varName, componentName) {
+    const entry = compilerCache.get(componentName);
+    if (!entry)
+        return '';
+    return (`\nObject.defineProperty(${varName}, '__preSource', { value: ${JSON.stringify(entry.preSource)}, enumerable: false, configurable: true })` +
+        `\nObject.defineProperty(${varName}, '__postSource', { value: ${JSON.stringify(entry.postSource)}, enumerable: false, configurable: true })` +
+        `\nObject.defineProperty(${varName}, '__msgMaskMap', { value: ${JSON.stringify(entry.msgMaskMap)}, enumerable: false, configurable: true })` +
+        `\nObject.defineProperty(${varName}, '__bindingSources', { value: ${JSON.stringify(entry.bindingSources)}, enumerable: false, configurable: true })`);
+}
+/**
+ * After the full output string is assembled, update each cached component's
+ * postSource (extract view body from the transformed output), then append
+ * Object.defineProperty calls for all four compiler-cache properties.
+ */
+export function appendCompilerCacheProps(output, componentDecls) {
+    let result = output;
+    for (const { varName, componentName } of componentDecls) {
+        const existing = compilerCache.get(componentName);
+        if (!existing)
+            continue;
+        // Update the cache entry with the post-transform view body
+        const postSource = extractViewBody(output) ?? '';
+        compilerCache.set(componentName, { ...existing, postSource });
+        // Append non-enumerable property definitions
+        result += generateCompilerCacheProps(varName, componentName);
+    }
+    return result;
+}
 //# sourceMappingURL=transform.js.map