@toolproof-core/schema 1.0.10 → 1.0.11

package/src/index.ts

@@ -27,49 +27,51 @@ export type {
 
 
 export type {
-  DocumentationFacet as DocumentationFacetJson,
-  NucleusFacet as NucleusFacetJson,
-  ResourceTypeIdentity as ResourceTypeIdentityJson,
-  ResourceType as ResourceTypeJson,
-  ResourceRoleIdentity as ResourceRoleIdentityJson,
-  ResourceRoleValue as ResourceRoleValueJson,
-  Conditional as ConditionalJson,
-  RoleMap as RoleMapJson,
-  Roles as RolesJson,
-  RoleBindings as RoleBindingsJson,
-  ResourceIdentity as ResourceIdentityJson,
-  JobStepIdentity as JobStepIdentityJson,
-  BranchStepIdentity as BranchStepIdentityJson,
-  WhileStepIdentity as WhileStepIdentityJson,
-  ForStepIdentity as ForStepIdentityJson,
-  JobStep as JobStepJson,
-  BranchStep as BranchStepJson,
-  WhileStep as WhileStepJson,
-  ForStep as ForStepJson,
-  StepKind as StepKindJson,
-  StepIdentity as StepIdentityJson,
-  Step as StepJson,
-  CreationContext as CreationContextJson,
-  ResourceMissing as ResourceMissingJson,
-  ResourceInputPotential as ResourceInputPotentialJson,
-  ResourceOutputPotential as ResourceOutputPotentialJson,
-  ShellMaterializedBase as ShellMaterializedBaseJson,
-  Resource as ResourceJson,
-  StrategyState as StrategyStateJson,
-  StepsFacet as StepsFacetJson,
-  RawStrategy as RawStrategyJson,
-  RunnableStrategyIdentity as RunnableStrategyIdentityJson,
-  RunnableStrategyStatus as RunnableStrategyStatusJson,
-  RunnableStrategy as RunnableStrategyJson,
-  RunnableStrategyUpdate as RunnableStrategyUpdateJson,
-  JobIdentity as JobIdentityJson,
-  Job as JobJson,
-  JsonData as JsonDataJson,
-  StrategyThreadIdentity as StrategyThreadIdentityJson,
-  StrategyThreadMap as StrategyThreadMapJson,
-  JobStepSocket as JobStepSocketJson,
-  Timestamp as TimestampJson,
-  StrategyRunIdentity as StrategyRunIdentityJson,
-  GoalIdentity as GoalIdentityJson,
-  Goal as GoalJson,
+  DocumentationFacetJson,
+  NucleusFacetJson,
+  ResourceTypeIdentityJson,
+  ResourceTypeJson,
+  ResourceRoleIdentityJson,
+  ResourceRoleValueJson,
+  ResourceRoleJson,
+  ConditionalJson,
+  RoleDictJson,
+  RolesJson,
+  RoleBindingsJson,
+  ResourceIdentityJson,
+  JobStepIdentityJson,
+  BranchStepIdentityJson,
+  WhileStepIdentityJson,
+  ForStepIdentityJson,
+  JobStepJson,
+  BranchStepJson,
+  WhileStepJson,
+  ForStepJson,
+  StepKindJson,
+  StepIdentityJson,
+  StepJson,
+  CreationContextJson,
+  ResourceMissingJson,
+  ResourceInputPotentialJson,
+  ResourceOutputPotentialJson,
+  ShellMaterializedBaseJson,
+  ResourceJson,
+  StrategyStateJson,
+  StepsFacetJson,
+  RawStrategyJson,
+  RunnableStrategyIdentityJson,
+  RunnableStrategyStatusJson,
+  RunnableStrategyJson,
+  RunnableStrategyUpdateJson,
+  JobIdentityJson,
+  JobJson,
+  JsonDataJson,
+  StrategyThreadIdentityJson,
+  StrategyThreadDictJson,
+  JobStepSocketJson,
+  TimestampJson,
+  StrategyRunIdentityJson,
+  GoalIdentityJson,
+  GoalJson,
+  ErrorJson,
 } from './generated/types/types.js';

package/src/scripts/generateStandaloneType.ts

@@ -11,8 +11,10 @@ import { getConfig } from "./_lib/config.js";
 // PURE: Generate the content of a standalone Resource type definition file for a given schema name.
 function generateStandaloneTypeLogic(name: string): string {
     const header = "// Auto-generated strict composite type. Do not edit.\n";
+
+    const nucleusTypeName = name.endsWith("Json") ? name : `${name}Json`;
     const ts =
-        `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../types.js";\n` +
+        `import type { ShellMaterializedBaseJson as ShellMaterializedBase, ${nucleusTypeName} as NucleusSchema } from "../types.js";\n` +
         `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }

package/src/scripts/generateTypes.ts

@@ -260,6 +260,148 @@ function escapeRegExpLiteral(value: string): string {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
+// PURE: Rename exported top-level generated declarations to canonical `*Json` names.
+// This makes editor hover/inference prefer `FooJson` because the underlying declared
+// symbol is `FooJson` (not `Foo` with a re-export alias).
+function applyReplacementsOutsideStringsAndComments(
+    text: string,
+    replaceCodeSegment: (code: string) => string,
+): string {
+    const len = text.length;
+    let out = '';
+
+    let i = 0;
+    let codeStart = 0;
+
+    const flushCode = (end: number) => {
+        if (end > codeStart) out += replaceCodeSegment(text.slice(codeStart, end));
+        codeStart = end;
+    };
+
+    const startsWith = (s: string) => text.startsWith(s, i);
+
+    while (i < len) {
+        // Line comment
+        if (startsWith('//')) {
+            flushCode(i);
+            const start = i;
+            i += 2;
+            while (i < len && text[i] !== '\n') i++;
+            if (i < len && text[i] === '\n') i++;
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+
+        // Block comment
+        if (startsWith('/*')) {
+            flushCode(i);
+            const start = i;
+            i += 2;
+            while (i < len && !text.startsWith('*/', i)) i++;
+            if (i < len) i += 2;
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+
+        const ch = text[i];
+
+        // Single-quoted string
+        if (ch === "'") {
+            flushCode(i);
+            const start = i;
+            i++;
+            while (i < len) {
+                const c = text[i];
+                if (c === '\\') {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (c === "'") break;
+            }
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+
+        // Double-quoted string
+        if (ch === '"') {
+            flushCode(i);
+            const start = i;
+            i++;
+            while (i < len) {
+                const c = text[i];
+                if (c === '\\') {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (c === '"') break;
+            }
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+
+        // Template literal (backticks). We conservatively treat the whole template as a string.
+        // The generated .d.ts uses these primarily for template-literal *value* types like `TYPE-${string}`
+        // and we do not want to rewrite their raw text.
+        if (ch === '`') {
+            flushCode(i);
+            const start = i;
+            i++;
+            while (i < len) {
+                const c = text[i];
+                if (c === '\\') {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                if (c === '`') break;
+            }
+            out += text.slice(start, i);
+            codeStart = i;
+            continue;
+        }
+
+        i++;
+    }
+
+    flushCode(len);
+    return out;
+}
+
+function renameExportedTopLevelTypesToJson(tsText: string): string {
+    // Collect exported type/interface names.
+    const exportedDeclRegex = /^export\s+(?:type|interface)\s+([A-Za-z_][A-Za-z0-9_]*)\b/gm;
+    const exportedNames = new Set<string>();
+    for (let m = exportedDeclRegex.exec(tsText); m; m = exportedDeclRegex.exec(tsText)) {
+        exportedNames.add(m[1]);
+    }
+
+    const renamePairs = Array.from(exportedNames)
+        .filter((name) => !name.endsWith('Json'))
+        .map((name) => ({ from: name, to: `${name}Json` }));
+
+    if (!renamePairs.length) return tsText;
+
+    // Replace longer names first to reduce any accidental partial-match risk.
+    renamePairs.sort((a, b) => b.from.length - a.from.length);
+
+    const replaceCode = (code: string) => {
+        let out = code;
+        for (const { from, to } of renamePairs) {
+            const re = new RegExp(`\\b${escapeRegExpLiteral(from)}\\b`, 'g');
+            out = out.replace(re, to);
+        }
+        return out;
+    };
+
+    return applyReplacementsOutsideStringsAndComments(tsText, replaceCode);
+}
+
 // PURE: Derive the TS value type for JobStepSocket from Genesis.json.
 // We prefer to match the schema shape:
 //   JobStepSocket.additionalProperties.oneOf = [#ResourcePotential, #Resource]
@@ -422,8 +564,8 @@ function postProcessEmittedTypes(ts: string, parsedSchema: any): string {
     const strategyThreadKeyType = 'StrategyThreadIdentity';
 
     ts = ts.replace(
-        /export interface RoleMap\s*{[^}]*}/g,
-        `export type RoleMap = Record<${resourceRoleKeyType}, ResourceRoleValue>;`
+        /export interface RoleDict\s*{[^}]*}/g,
+        `export type RoleDict = Record<${resourceRoleKeyType}, ResourceRoleValue>;`
     );
     // Normalize StrategyState & related socket maps to identity-keyed Records.
     // These are emitted as `[k: string]` by json-schema-to-typescript but are identity-keyed in practice.
@@ -450,15 +592,19 @@ function postProcessEmittedTypes(ts: string, parsedSchema: any): string {
         `$1Record<${jobStepKeyType}, JobStepSocket>;`
     );
 
-    // Ensure key constraints for strategyThreadMap are preserved as template-literal identity keys.
+    // Ensure key constraints for strategyThreadDict are preserved as template-literal identity keys.
     // json-schema-to-typescript emits `[k: string]: StepArray;`, but we want keys to be `StrategyThreadIdentity`.
     ts = ts.replace(
-        /export interface StrategyThreadMap\s*\{\s*\[k:\s*string\]:\s*StepArray;\s*\}/g,
-        `export type StrategyThreadMap = Record<${strategyThreadKeyType}, StepArray>;`
+        /export interface StrategyThreadDict\s*\{\s*\[k:\s*string\]:\s*StepArray;\s*\}/g,
+        `export type StrategyThreadDict = Record<${strategyThreadKeyType}, StepArray>;`
     );
 
     ts = fixJsonDataSelfReference(ts);
 
+    // IMPORTANT: do this last so earlier post-processing regexes can target
+    // the generator's original names (without `Json` suffixes).
+    ts = renameExportedTopLevelTypesToJson(ts);
+
     return ts;
 }