@openwebf/webf 0.23.10 → 0.24.1

package/test/agents-init.test.ts

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { agentsInitCommand } from '../src/agents';
+
+function readText(filePath: string) {
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+describe('webf agents init', () => {
+  let tempDir: string;
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webf-agents-init-'));
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('initializes a new project with skills and CLAUDE.md', async () => {
+    await agentsInitCommand(tempDir);
+
+    expect(fs.existsSync(path.join(tempDir, 'CLAUDE.md'))).toBe(true);
+    expect(fs.existsSync(path.join(tempDir, '.claude', 'skills', 'webf-quickstart', 'SKILL.md'))).toBe(true);
+
+    const claude = readText(path.join(tempDir, 'CLAUDE.md'));
+    expect(claude).toContain('<!-- webf-agents:init start -->');
+    expect(claude).toContain('Source: `@openwebf/claude-code-skills@');
+    expect(claude).toContain('### Skills');
+
+    const version = readText(path.join(tempDir, '.claude', 'webf-claude-code-skills.version'));
+    expect(version).toMatch(/^@openwebf\/claude-code-skills@/);
+  });
+
+  it('updates an existing CLAUDE.md without removing existing content', async () => {
+    fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '# Existing\n\nHello\n', 'utf-8');
+
+    await agentsInitCommand(tempDir);
+
+    const claude = readText(path.join(tempDir, 'CLAUDE.md'));
+    expect(claude).toContain('# Existing');
+    expect(claude).toContain('Hello');
+    expect(claude).toContain('<!-- webf-agents:init start -->');
+  });
+
+  it('is idempotent (does not duplicate the injected block)', async () => {
+    await agentsInitCommand(tempDir);
+    await agentsInitCommand(tempDir);
+
+    const claude = readText(path.join(tempDir, 'CLAUDE.md'));
+    const occurrences = claude.split('<!-- webf-agents:init start -->').length - 1;
+    expect(occurrences).toBe(1);
+  });
+
+  it('backs up modified skill files before overwriting', async () => {
+    const skillDir = path.join(tempDir, '.claude', 'skills', 'webf-quickstart');
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), 'local edits', 'utf-8');
+
+    await agentsInitCommand(tempDir);
+
+    const files = fs.readdirSync(skillDir);
+    expect(files.some(f => f.startsWith('SKILL.md.bak.'))).toBe(true);
+
+    const sourceSkill = fs.readFileSync(
+      path.join(
+        path.dirname(require.resolve('@openwebf/claude-code-skills/package.json')),
+        'webf-quickstart',
+        'SKILL.md'
+      ),
+      'utf-8'
+    );
+    const installedSkill = readText(path.join(skillDir, 'SKILL.md'));
+    expect(installedSkill).toBe(sourceSkill);
+  });
+});

package/test/commands.test.ts

@@ -230,8 +230,8 @@ describe('Commands', () => {
 
         expect(mockSpawnSync).toHaveBeenCalledWith(
           expect.stringMatching(/npm(\.cmd)?/),
-          ['install'],
-          { cwd: target, stdio: 'inherit' }
+          ['install', '--production=false'],
+          expect.objectContaining({ cwd: target, stdio: 'inherit' })
         );
       });
     });
@@ -283,18 +283,11 @@ describe('Commands', () => {
         
         await generateCommand(target, options);
 
-        // Should install WebF typings
+        // Should install dependencies (including devDependencies) from package.json
         expect(mockSpawnSync).toHaveBeenCalledWith(
           expect.stringMatching(/npm(\.cmd)?/),
-          ['install', '@openwebf/webf-enterprise-typings'],
-          { cwd: target, stdio: 'inherit' }
-        );
-
-        // Should install Vue 3 as dev dependency
-        expect(mockSpawnSync).toHaveBeenCalledWith(
-          expect.stringMatching(/npm(\.cmd)?/),
-          ['install', 'vue', '-D'],
-          { cwd: target, stdio: 'inherit' }
+          ['install', '--production=false'],
+          expect.objectContaining({ cwd: target, stdio: 'inherit' })
         );
       });
     });

package/test/generator.test.ts

@@ -233,19 +233,13 @@ describe('Generator', () => {
         command: 'test command'
       });
       
-      // Check that index.d.ts was written
+      // Dart codegen does not write a root index.d.ts; it copies .d.ts files alongside generated Dart bindings.
       const writeFileCalls = mockFs.writeFileSync.mock.calls;
       const indexDtsCall = writeFileCalls.find(call => 
         call[0].toString().endsWith('index.d.ts')
       );
       
-      expect(indexDtsCall).toBeDefined();
-      expect(indexDtsCall![1]).toContain('/// <reference path="./global.d.ts" />');
-      expect(indexDtsCall![1]).toContain('/// <reference path="./components/button.d.ts" />');
-      expect(indexDtsCall![1]).toContain('/// <reference path="./widgets/card.d.ts" />');
-      expect(indexDtsCall![1]).toContain("export * from './components/button';");
-      expect(indexDtsCall![1]).toContain("export * from './widgets/card';");
-      expect(indexDtsCall![1]).toContain('TypeScript Definitions');
+      expect(indexDtsCall).toBeUndefined();
     });
     
     it('should copy original .d.ts files to output directory', async () => {
@@ -301,6 +295,19 @@ describe('Generator', () => {
       expect(mockFs.writeFileSync).toHaveBeenCalled();
     });
 
+    it('should always generate src/types.ts for React output', async () => {
+      await reactGen({
+        source: '/test/source',
+        target: '/test/target',
+        command: 'test command'
+      });
+
+      const writeCalls = mockFs.writeFileSync.mock.calls;
+      const typesCall = writeCalls.find(call => /[\\/]src[\\/]types\.ts$/.test(call[0].toString()));
+      expect(typesCall).toBeDefined();
+      expect(typesCall![1]).toContain('export {};');
+    });
+
     it('should use the exact target directory specified', async () => {
       await reactGen({
         source: '/test/source',
@@ -478,8 +485,8 @@ describe('Generator', () => {
       // First file fails (no writes), second file succeeds (1 dart + 1 .d.ts), plus index.d.ts = 3 total
       // But since the error happens in dartGen, the .d.ts copy might not happen
       const writeCalls = mockFs.writeFileSync.mock.calls;
-      // Should have at least written the successful dart file and index.d.ts
-      expect(writeCalls.length).toBeGreaterThanOrEqual(2);
+      // Should have at least written the successful Dart bindings file
+      expect(writeCalls.length).toBeGreaterThanOrEqual(1);
     });
   });
 

package/test/peerDeps.test.ts

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+
+import { getPackageTypesFileFromDir, isPackageTypesReady } from '../src/peerDeps';
+
+function makeTempDir(prefix: string): string {
+  return fs.mkdtempSync(path.join(process.cwd(), 'test', prefix));
+}
+
+describe('peerDeps', () => {
+  it('treats package as not ready when declared types file is missing', () => {
+    const dir = makeTempDir('peerDeps-');
+    const distDir = path.join(dir, 'dist');
+    try {
+      fs.mkdirSync(distDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(dir, 'package.json'),
+        JSON.stringify({ name: '@openwebf/react-core-ui', types: 'dist/index.d.ts' }, null, 2)
+      );
+
+      expect(getPackageTypesFileFromDir(dir)).toBe(path.join(dir, 'dist', 'index.d.ts'));
+      expect(isPackageTypesReady(dir)).toBe(false);
+
+      fs.writeFileSync(path.join(distDir, 'index.d.ts'), 'export {};');
+      expect(isPackageTypesReady(dir)).toBe(true);
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/test/react-consts.test.ts

@@ -1,15 +1,18 @@
 import { generateReactComponent } from '../src/react';
 import { IDLBlob } from '../src/IDLBlob';
-import { ConstObject, EnumObject, EnumMemberObject } from '../src/declaration';
+import { ClassObject, ClassObjectKind, ConstObject, EnumObject, EnumMemberObject } from '../src/declaration';
 
 describe('React generator - declare const support', () => {
   it('emits export declare const for constants from typings', () => {
     const blob = new IDLBlob('/test/source', '/test/target', 'ConstOnly', 'test', '');
+    const properties = new ClassObject();
+    properties.name = 'TestComponentProperties';
+    properties.kind = ClassObjectKind.interface;
     const constObj = new ConstObject();
     constObj.name = 'WEBF_CUPERTINO_SYMBOL';
     constObj.type = 'unique symbol';
 
-    blob.objects = [constObj as any];
+    blob.objects = [properties, constObj as any];
 
     const output = generateReactComponent(blob);
     expect(output).toContain('export declare const WEBF_CUPERTINO_SYMBOL: unique symbol;');
@@ -17,12 +20,15 @@ describe('React generator - declare const support', () => {
 
   it('emits export declare enum for enums from typings', () => {
     const blob = new IDLBlob('/test/source', '/test/target', 'EnumOnly', 'test', '');
+    const properties = new ClassObject();
+    properties.name = 'TestComponentProperties';
+    properties.kind = ClassObjectKind.interface;
     const eo = new EnumObject();
     eo.name = 'CupertinoColors';
     const m1 = new EnumMemberObject(); m1.name = "'red'"; m1.initializer = '0x0f';
     const m2 = new EnumMemberObject(); m2.name = "'bbb'"; m2.initializer = '0x00';
     eo.members = [m1, m2];
-    blob.objects = [eo as any];
+    blob.objects = [properties, eo as any];
 
     const output = generateReactComponent(blob);
     expect(output).toContain("export enum CupertinoColors { 'red' = 0x0f, 'bbb' = 0x00 }");

package/test/standard-props.test.ts

@@ -49,13 +49,13 @@ describe('Standard HTML Props Generation', () => {
       const propsContent = result.substring(propsStart, propsEnd);
       
       // Verify order: custom props, event handlers, then standard HTML props
-      const labelIndex = propsContent.indexOf('label: dom_string;');
-      const variantIndex = propsContent.indexOf('variant?: dom_string;');
-      const onClickIndex = propsContent.indexOf('onClick?: (event: Event) => void;');
-      const idIndex = propsContent.indexOf('id?: string;');
-      const styleIndex = propsContent.indexOf('style?: React.CSSProperties;');
-      const childrenIndex = propsContent.indexOf('children?: React.ReactNode;');
-      const classNameIndex = propsContent.indexOf('className?: string;');
+      const labelIndex = propsContent.search(/\n\s*label\??:\s*/);
+      const variantIndex = propsContent.search(/\n\s*variant\??:\s*/);
+      const onClickIndex = propsContent.search(/\n\s*onClick\??:\s*/);
+      const idIndex = propsContent.search(/\n\s*id\??:\s*/);
+      const styleIndex = propsContent.search(/\n\s*style\??:\s*/);
+      const childrenIndex = propsContent.search(/\n\s*children\??:\s*/);
+      const classNameIndex = propsContent.search(/\n\s*className\??:\s*/);
       
       // All props should exist
       expect(labelIndex).toBeGreaterThan(-1);
@@ -131,8 +131,8 @@ describe('Standard HTML Props Generation', () => {
       
       // Standard HTML props
       expect(propsContent).toContain("'id'?: string;");
-      expect(propsContent).toContain("'class'?: string;");
-      expect(propsContent).toContain("'style'?: string | Record<string, any>;");
+      expect(propsContent).toContain("'class'?: ClassValue;");
+      expect(propsContent).toContain("'style'?: StyleValue;");
     });
 
     it('should handle Vue style prop with both string and object types', () => {
@@ -145,8 +145,8 @@ describe('Standard HTML Props Generation', () => {
       
       const result = generateVueTypings([blob]);
       
-      // Vue style prop should accept both string and object
-      expect(result).toMatch(/'style'\?: string \| Record<string, any>;/);
+      // Vue style prop should accept Vue's supported style value forms
+      expect(result).toMatch(/'style'\?: StyleValue;/);
     });
   });
 
@@ -176,15 +176,15 @@ describe('Standard HTML Props Generation', () => {
       
       // Both should have style prop (with appropriate types)
       expect(reactResult).toContain('style?: React.CSSProperties;');
-      expect(vueResult).toContain("'style'?: string | Record<string, any>;");
+      expect(vueResult).toContain("'style'?: StyleValue;");
       
       // React has className, Vue has class
       expect(reactResult).toContain('className?: string;');
-      expect(vueResult).toContain("'class'?: string;");
+      expect(vueResult).toContain("'class'?: ClassValue;");
       
       // React has children, Vue uses slots (not in props)
       expect(reactResult).toContain('children?: React.ReactNode;');
       expect(vueResult).not.toContain('children');
     });
   });
-});
+});

package/test/templates.test.ts

@@ -0,0 +1,17 @@
+import fs from 'fs';
+import path from 'path';
+
+describe('Templates', () => {
+  it('react tsconfig template pins React type resolution to root @types', () => {
+    const templatePath = path.resolve(__dirname, '../templates/react.tsconfig.json.tpl');
+    const template = fs.readFileSync(templatePath, 'utf8');
+
+    expect(template).toContain('"baseUrl": "."');
+    expect(template).toContain('"paths"');
+    expect(template).toContain('"react": ["./node_modules/@types/react/index.d.ts"]');
+    expect(template).toContain('"react-dom": ["./node_modules/@types/react-dom/index.d.ts"]');
+    expect(template).toContain('"react/jsx-runtime": ["./node_modules/@types/react/jsx-runtime.d.ts"]');
+    expect(template).toContain('"react/jsx-dev-runtime": ["./node_modules/@types/react/jsx-dev-runtime.d.ts"]');
+  });
+});
+

package/test/vue.test.ts

@@ -1,6 +1,6 @@
 import { generateVueTypings } from '../src/vue';
 import { IDLBlob } from '../src/IDLBlob';
-import { ClassObject, ClassObjectKind, PropsDeclaration, ConstObject } from '../src/declaration';
+import { ClassObject, ClassObjectKind, PropsDeclaration, ConstObject, TypeAliasObject } from '../src/declaration';
 
 describe('Vue Generator', () => {
   describe('generateVueTypings', () => {
@@ -16,13 +16,16 @@ describe('Vue Generator', () => {
       
       // Should include standard HTML props in Props type
       expect(result).toContain("'id'?: string;");
-      expect(result).toContain("'class'?: string;");
-      expect(result).toContain("'style'?: string | Record<string, any>;");
+      expect(result).toContain("'class'?: ClassValue;");
+      expect(result).toContain("'style'?: StyleValue;");
       
       // Should generate proper type exports
       expect(result).toContain('export type TestComponentProps = {');
       expect(result).toContain('export interface TestComponentElement {');
       expect(result).toContain('export type TestComponentEvents = {');
+
+      // Should not rely on a non-existent internal __webfTypes import
+      expect(result).not.toContain('__webfTypes');
     });
 
     it('should include standard HTML props along with custom properties', () => {
@@ -58,8 +61,8 @@ describe('Vue Generator', () => {
       
       // And still include standard HTML props
       expect(result).toContain("'id'?: string;");
-      expect(result).toContain("'class'?: string;");
-      expect(result).toContain("'style'?: string | Record<string, any>;");
+      expect(result).toContain("'class'?: ClassValue;");
+      expect(result).toContain("'style'?: StyleValue;");
     });
 
     it('should generate proper Vue component declarations', () => {
@@ -73,11 +76,20 @@ describe('Vue Generator', () => {
       const result = generateVueTypings([blob]);
       
       // Should generate proper component declarations
-      expect(result).toContain("declare module 'vue' {");
+      expect(result).toContain("declare module '@vue/runtime-core' {");
+      expect(result).toContain("interface GlobalDirectives {");
+      expect(result).toContain('vFlutterAttached: typeof flutterAttached;');
       expect(result).toContain("interface GlobalComponents {");
-      expect(result).toContain("'web-f-list-view': DefineCustomElement<");
+      expect(result).toContain("'webf-list-view': DefineCustomElement<");
+      expect(result).not.toContain("'web-f-list-view': DefineCustomElement<");
+      expect(result).toContain("WebFListViewElement,");
       expect(result).toContain("WebFListViewProps,");
       expect(result).toContain("WebFListViewEvents");
+
+      // Compatibility module for older tooling
+      expect(result).toContain("declare module 'vue' {");
+      expect(result).toContain("interface GlobalDirectives extends import('@vue/runtime-core').GlobalDirectives {}");
+      expect(result).toContain("interface GlobalComponents extends import('@vue/runtime-core').GlobalComponents {}");
     });
 
     it('should handle multiple components', () => {
@@ -145,13 +157,13 @@ describe('Vue Generator', () => {
       
       // Should include event types
       expect(result).toContain('export type TestComponentEvents = {');
-      expect(result).toContain('close?: Event;');
-      expect(result).toContain('refresh?: CustomEvent;');
+      expect(result).toContain('close: Event;');
+      expect(result).toContain('refresh: CustomEvent;');
       
       // Props should still have standard HTML props
       expect(result).toContain("'id'?: string;");
-      expect(result).toContain("'class'?: string;");
-      expect(result).toContain("'style'?: string | Record<string, any>;");
+      expect(result).toContain("'class'?: ClassValue;");
+      expect(result).toContain("'style'?: StyleValue;");
     });
 
     it('should include declare const variables as exported declarations', () => {
@@ -168,6 +180,19 @@ describe('Vue Generator', () => {
       expect(result).toContain('export declare const WEBF_UNIQUE: unique symbol;');
     });
 
+    it('should include type aliases as exported declarations', () => {
+      const blob = new IDLBlob('/test/source', '/test/target', 'TypeAliasOnly', 'test', '');
+
+      const typeAlias = new TypeAliasObject();
+      typeAlias.name = 'MyAlias';
+      typeAlias.type = 'string | number';
+
+      blob.objects = [typeAlias as any];
+
+      const result = generateVueTypings([blob]);
+      expect(result).toContain('export type MyAlias = string | number;');
+    });
+
     it('should include declare enum as exported declaration', () => {
       const blob = new IDLBlob('/test/source', '/test/target', 'EnumOnly', 'test', '');
       // Build a minimal faux EnumObject via analyzer by simulating ast is heavy; create a shape

package/dist/constants.js

@@ -1,242 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUnionConstantsValuesTs = generateUnionConstantsValuesTs;
-exports.generateUnionConstantsDts = generateUnionConstantsDts;
-exports.generateDeclaredConstantsValuesTs = generateDeclaredConstantsValuesTs;
-exports.generateDeclaredConstantsDts = generateDeclaredConstantsDts;
-const lodash_1 = __importDefault(require("lodash"));
-const typescript_1 = __importDefault(require("typescript"));
-const dart_1 = require("./dart");
-// Generate constant name from component (Properties/Bindings trimmed) and prop name
-function getConstName(className, propName) {
-    const baseName = className.replace(/Properties$|Bindings$/, '');
-    return baseName + lodash_1.default.upperFirst(lodash_1.default.camelCase(propName));
-}
-function collectUnionStringProps(blobs) {
-    const results = [];
-    for (const blob of blobs) {
-        const classObjects = (blob.objects || []);
-        const properties = classObjects.filter(obj => obj.name && obj.name.endsWith('Properties'));
-        if (!properties.length)
-            continue;
-        const componentProps = properties[0];
-        const componentName = componentProps.name.replace(/Properties$/, '');
-        for (const prop of componentProps.props || []) {
-            if (!(0, dart_1.isStringUnionType)(prop.type))
-                continue;
-            const values = (0, dart_1.getUnionStringValues)(prop, blob);
-            if (!values || values.length === 0)
-                continue;
-            const constName = getConstName(componentProps.name, prop.name);
-            results.push({ constName, values, className: componentName, propName: prop.name });
-        }
-    }
-    return results;
-}
-function generateUnionConstantsValuesTs(blobs) {
-    const items = collectUnionStringProps(blobs);
-    if (!items.length)
-        return '';
-    const header = `// Auto-generated by WebF CLI\n// Constants for string-union properties extracted from .d.ts definitions\n`;
-    const blocks = items.map(item => {
-        const entries = item.values.map(v => `  '${v}': '${v}',`).join('\n');
-        return `// ${item.className}.${item.propName}\nexport const ${item.constName} = {\n${entries}\n} as const;`;
-    });
-    return [header, ...blocks].join('\n\n') + '\n';
-}
-function generateUnionConstantsDts(blobs) {
-    const items = collectUnionStringProps(blobs);
-    if (!items.length)
-        return '';
-    const header = `// Auto-generated by WebF CLI\n// Type declarations for constants representing string-union property values\n`;
-    const blocks = items.map(item => {
-        const entries = item.values.map(v => `  readonly '${v}': '${v}';`).join('\n');
-        return `// ${item.className}.${item.propName}\nexport declare const ${item.constName}: {\n${entries}\n};`;
-    });
-    return [header, ...blocks].join('\n\n') + '\n';
-}
-function parseLiteralFromType(node) {
-    if (typescript_1.default.isLiteralTypeNode(node)) {
-        const lit = node.literal;
-        if (typescript_1.default.isStringLiteral(lit))
-            return lit.text;
-        if (typescript_1.default.isNumericLiteral(lit))
-            return Number(lit.text);
-        if (lit.kind === typescript_1.default.SyntaxKind.TrueKeyword)
-            return true;
-        if (lit.kind === typescript_1.default.SyntaxKind.FalseKeyword)
-            return false;
-        return null;
-    }
-    if (typescript_1.default.isTypeQueryNode(node)) {
-        // typeof Identifier
-        if (typescript_1.default.isIdentifier(node.exprName)) {
-            return { typeofRef: node.exprName.text };
-        }
-    }
-    return null;
-}
-function collectDeclaredConstsFromSource(content, fileName = 'index.d.ts') {
-    const source = typescript_1.default.createSourceFile(fileName, content, typescript_1.default.ScriptTarget.ES2020, true, typescript_1.default.ScriptKind.TS);
-    const results = [];
-    const handleVariableStatement = (stmt) => {
-        // Only consider const declarations
-        if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
-            return;
-        for (const decl of stmt.declarationList.declarations) {
-            if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
-                continue;
-            const name = decl.name.text;
-            const val = parseLiteralFromType(decl.type);
-            if (val == null)
-                continue;
-            results.push({ kind: 'const', name, value: val });
-        }
-    };
-    const handleClass = (cls) => {
-        var _a, _b, _c;
-        const container = (_a = cls.name) === null || _a === void 0 ? void 0 : _a.text;
-        if (!container)
-            return;
-        for (const m of cls.members) {
-            if (!typescript_1.default.isPropertyDeclaration(m))
-                continue;
-            const isStatic = (_b = m.modifiers) === null || _b === void 0 ? void 0 : _b.some(mod => mod.kind === typescript_1.default.SyntaxKind.StaticKeyword);
-            const isReadonly = (_c = m.modifiers) === null || _c === void 0 ? void 0 : _c.some(mod => mod.kind === typescript_1.default.SyntaxKind.ReadonlyKeyword);
-            if (!isStatic || !isReadonly || !m.type)
-                continue;
-            if (!typescript_1.default.isIdentifier(m.name))
-                continue;
-            const name = m.name.text;
-            const val = parseLiteralFromType(m.type);
-            if (val == null)
-                continue;
-            results.push({ kind: 'container', container, name, value: val });
-        }
-    };
-    const handleModule = (mod) => {
-        const container = mod.name.getText(source).replace(/['"]/g, '');
-        if (!mod.body || !typescript_1.default.isModuleBlock(mod.body))
-            return;
-        for (const stmt of mod.body.statements) {
-            if (typescript_1.default.isVariableStatement(stmt)) {
-                if ((stmt.declarationList.flags & typescript_1.default.NodeFlags.Const) === 0)
-                    continue;
-                for (const decl of stmt.declarationList.declarations) {
-                    if (!typescript_1.default.isIdentifier(decl.name) || !decl.type)
-                        continue;
-                    const name = decl.name.text;
-                    const val = parseLiteralFromType(decl.type);
-                    if (val == null)
-                        continue;
-                    results.push({ kind: 'container', container, name, value: val });
-                }
-            }
-        }
-    };
-    for (const stmt of source.statements) {
-        if (typescript_1.default.isVariableStatement(stmt))
-            handleVariableStatement(stmt);
-        else if (typescript_1.default.isClassDeclaration(stmt))
-            handleClass(stmt);
-        else if (typescript_1.default.isModuleDeclaration(stmt))
-            handleModule(stmt);
-    }
-    return results;
-}
-function collectDeclaredConsts(blobs) {
-    const all = [];
-    for (const blob of blobs) {
-        const raw = blob.raw || '';
-        if (!raw)
-            continue;
-        try {
-            const items = collectDeclaredConstsFromSource(raw, blob.filename + '.d.ts');
-            all.push(...items);
-        }
-        catch (_) {
-            // ignore parse errors per file
-        }
-    }
-    return all;
-}
-function literalToTsValue(val) {
-    if (typeof val === 'string')
-        return `'${val.replace(/'/g, "\\'")}'`;
-    if (typeof val === 'number')
-        return String(val);
-    if (typeof val === 'boolean')
-        return val ? 'true' : 'false';
-    if (typeof val.typeofRef === 'string')
-        return val.typeofRef;
-    return 'undefined';
-}
-function generateDeclaredConstantsValuesTs(blobs) {
-    const items = collectDeclaredConsts(blobs);
-    if (!items.length)
-        return '';
-    const header = `// Auto-generated by WebF CLI\n// Runtime constants mirrored from .d.ts 'declare const' definitions\n`;
-    const topLevel = [];
-    const containers = new Map();
-    for (const it of items) {
-        if (it.kind === 'const') {
-            topLevel.push(`export const ${it.name} = ${literalToTsValue(it.value)} as const;`);
-        }
-        else {
-            if (!containers.has(it.container))
-                containers.set(it.container, []);
-            containers.get(it.container).push(it);
-        }
-    }
-    const containerBlocks = [];
-    for (const [container, arr] of containers) {
-        const lines = arr
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map(a => `  ${a.name}: ${literalToTsValue(a.value)},`) // keep plain object
-            .join('\n');
-        containerBlocks.push(`export const ${container} = {\n${lines}\n} as const;`);
-    }
-    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
-}
-function generateDeclaredConstantsDts(blobs) {
-    const items = collectDeclaredConsts(blobs);
-    if (!items.length)
-        return '';
-    const header = `// Auto-generated by WebF CLI\n// Type declarations for 'declare const' values mirrored into JS runtime\n`;
-    const topLevel = [];
-    const containers = new Map();
-    for (const it of items) {
-        if (it.kind === 'const') {
-            const val = typeof it.value === 'object' && it.value.typeofRef
-                ? `typeof ${it.value.typeofRef}`
-                : typeof it.value === 'string'
-                    ? `'${it.value.replace(/'/g, "\\'")}'`
-                    : String(it.value);
-            topLevel.push(`export declare const ${it.name}: ${val};`);
-        }
-        else {
-            if (!containers.has(it.container))
-                containers.set(it.container, []);
-            containers.get(it.container).push(it);
-        }
-    }
-    const containerBlocks = [];
-    for (const [container, arr] of containers) {
-        const lines = arr
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map(a => {
-            const v = typeof a.value === 'object' && a.value.typeofRef
-                ? `typeof ${a.value.typeofRef}`
-                : typeof a.value === 'string'
-                    ? `'${a.value.replace(/'/g, "\\'")}'`
-                    : String(a.value);
-            return `  readonly ${a.name}: ${v};`;
-        })
-            .join('\n');
-        containerBlocks.push(`export declare const ${container}: {\n${lines}\n};`);
-    }
-    return [header, ...topLevel, ...containerBlocks].filter(Boolean).join('\n\n') + '\n';
-}