@toolproof-core/schema 1.0.4 → 1.0.5

package/dist/scripts/_lib/config.js

@@ -20,14 +20,12 @@ export class SchemaConfig {
         this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
         this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/');
         this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
-        // Intermediate, generated artifact produced by normalizeAnchorsToPointers.
-        // This should NOT live next to the source-of-truth schemas.
         this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/generated/normalized');
         this.schemasDir = getEnv('TP_SCHEMA_SCHEMAS_DIR', 'src/generated/schemas');
         this.resourcesDir = getEnv('TP_SCHEMA_RESOURCES_DIR', 'src/generated/resources');
         this.dependencyMapPath = getEnv('TP_SCHEMA_DEPENDENCY_MAP_PATH', 'src/generated/dependencies/dependencyMap.json');
-        this.typesTsSrcDir = getEnv('TP_SCHEMA_TYPES_TS_SRC_DIR', 'src/generated/typesTS');
-        this.typesTsDistDir = getEnv('TP_SCHEMA_TYPES_TS_DIST_DIR', 'dist/generated/typesTS');
+        this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/generated/types');
+        this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/generated/types');
         this.baseUrl = getEnv('TP_SCHEMA_BASE_URL', 'https://schemas.toolproof.com');
         this.version = getEnv('TP_SCHEMA_VERSION', 'v0');
     }
@@ -68,39 +66,39 @@ export class SchemaConfig {
     getSchemaPath(filename) {
         return path.join(this.getSchemasDir(), filename);
     }
-    getSchemasStandaloneDir() {
+    getStandaloneSchemaDir() {
         return path.join(this.getSchemasDir(), 'standalone');
     }
-    getSchemaStandalonePath(filename) {
-        return path.join(this.getSchemasStandaloneDir(), filename);
+    getStandaloneSchemaPath(filename) {
+        return path.join(this.getStandaloneSchemaDir(), filename);
     }
-    getTypesTsSrcDir() {
-        return path.isAbsolute(this.typesTsSrcDir)
-            ? this.typesTsSrcDir
-            : path.join(this.root, this.typesTsSrcDir);
+    getTypesSrcDir() {
+        return path.isAbsolute(this.typesSrcDir)
+            ? this.typesSrcDir
+            : path.join(this.root, this.typesSrcDir);
     }
-    getTypesTsDistDir() {
-        return path.isAbsolute(this.typesTsDistDir)
-            ? this.typesTsDistDir
-            : path.join(this.root, this.typesTsDistDir);
+    getTypesDistDir() {
+        return path.isAbsolute(this.typesDistDir)
+            ? this.typesDistDir
+            : path.join(this.root, this.typesDistDir);
     }
-    getTypesTsSrcPath(filename) {
-        return path.join(this.getTypesTsSrcDir(), filename);
+    getTypesSrcPath(filename) {
+        return path.join(this.getTypesSrcDir(), filename);
     }
-    getTypesTsDistPath(filename) {
-        return path.join(this.getTypesTsDistDir(), filename);
+    getTypesDistPath(filename) {
+        return path.join(this.getTypesDistDir(), filename);
     }
-    getStandaloneTypeTsSrcDir() {
-        return path.join(this.getTypesTsSrcDir(), 'standalone');
+    getStandaloneTypeSrcDir() {
+        return path.join(this.getTypesSrcDir(), 'standalone');
     }
-    getStandaloneTypeTsDistDir() {
-        return path.join(this.getTypesTsDistDir(), 'standalone');
+    getStandaloneTypeDistDir() {
+        return path.join(this.getTypesDistDir(), 'standalone');
     }
-    getStandaloneTypeTsSrcPath(filename) {
-        return path.join(this.getStandaloneTypeTsSrcDir(), filename);
+    getStandaloneTypeSrcPath(filename) {
+        return path.join(this.getStandaloneTypeSrcDir(), filename);
     }
-    getStandaloneTypeTsDistPath(filename) {
-        return path.join(this.getStandaloneTypeTsDistDir(), filename);
+    getStandaloneTypeDistPath(filename) {
+        return path.join(this.getStandaloneTypeDistDir(), filename);
     }
     getResourcesDir() {
         return path.isAbsolute(this.resourcesDir)

package/dist/scripts/generateSchemaShims.js

@@ -10,7 +10,7 @@ import { getConfig } from './_lib/config.js';
  *
  * Generates shims for:
  * - schemas dir: config.getSchemasDir() (schema files)
- * - standalone schemas dir: config.getSchemasStandaloneDir() (standalone schema files)
+ * - standalone schemas dir: config.getStandaloneSchemaDir() (standalone schema files)
  * - resources dir: config.getResourcesDir() (resource envelope files)
  *
  * Usage: node ./dist/scripts/generateSchemaShims.js
@@ -34,7 +34,7 @@ function main() {
     try {
         const config = getConfig();
         const schemasDir = config.getSchemasDir();
-        const standaloneSchemasDir = config.getSchemasStandaloneDir();
+        const standaloneSchemasDir = config.getStandaloneSchemaDir();
         const resourcesDir = config.getResourcesDir();
         const generatedResourceTypesDir = config.getNormalizedDir();
         let totalCount = 0;

package/dist/scripts/generateStandaloneSchema.js

@@ -154,7 +154,7 @@ async function main() {
         }
         const schemasDir = config.getSchemasDir();
         const genesisPath = path.join(schemasDir, config.getSourceFile());
-        const outPath = config.getSchemaStandalonePath(`${name}.json`);
+        const outPath = config.getStandaloneSchemaPath(`${name}.json`);
         if (!fs.existsSync(genesisPath)) {
             throw new Error(`Genesis.json not found at ${genesisPath}. Run extractSchemasFromResourceTypeShells first.`);
         }

package/dist/scripts/{generateStandaloneTypeTS.js → generateStandaloneType.js}

@@ -4,12 +4,12 @@ import { getConfig } from "./_lib/config.js";
  * Generate a typed Resource variant where `nucleus` is typed to a specific schema
  * extracted under the configured output directory.
  *
- * Usage: node ./dist/scripts/generateStandaloneType.js --name Job
+ * Usage: node ./dist/scripts/generateStandaloneTypes.js --name Job
  */
 // PURE: Generate the content of a standalone Resource type definition file for a given schema name.
 function generateStandaloneTypeLogic(name) {
     const header = "// Auto-generated strict composite type. Do not edit.\n";
-    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../typesTS.js";\n` +
+    const ts = `import type { ShellMaterializedBase, ${name} as NucleusSchema } from "../types.js";\n` +
         `export type Resource_${name} = ShellMaterializedBase & { nucleus: NucleusSchema };\n`;
     return header + ts;
 }
@@ -57,7 +57,7 @@ function main() {
         }
         const inPath = name === "Genesis"
             ? config.getSchemaPath("Genesis.json")
-            : config.getSchemaStandalonePath(`${name}.json`);
+            : config.getStandaloneSchemaPath(`${name}.json`);
         if (!fs.existsSync(inPath)) {
             if (name === "Genesis") {
                 console.error(`Schema file not found: ${inPath}`);
@@ -79,12 +79,12 @@ function main() {
         // Output setup
         const outName = `Resource_${name}.d.ts`;
         const outJsName = `Resource_${name}.js`;
-        const outDir = config.getStandaloneTypeTsSrcDir();
-        const distLibDir = config.getStandaloneTypeTsDistDir();
+        const outDir = config.getStandaloneTypeSrcDir();
+        const distLibDir = config.getStandaloneTypeDistDir();
         // Process src output
         fs.mkdirSync(outDir, { recursive: true });
-        const outPath = config.getStandaloneTypeTsSrcPath(outName);
-        const outJsPath = config.getStandaloneTypeTsSrcPath(outJsName);
+        const outPath = config.getStandaloneTypeSrcPath(outName);
+        const outJsPath = config.getStandaloneTypeSrcPath(outJsName);
         fs.writeFileSync(outPath, tsContent, "utf8");
         console.log(`Wrote ${outPath}`);
         if (!fs.existsSync(outJsPath)) {
@@ -93,8 +93,8 @@ function main() {
         }
         // Process dist output
         fs.mkdirSync(distLibDir, { recursive: true });
-        const distDtsPath = config.getStandaloneTypeTsDistPath(outName);
-        const distJsPath = config.getStandaloneTypeTsDistPath(outJsName);
+        const distDtsPath = config.getStandaloneTypeDistPath(outName);
+        const distJsPath = config.getStandaloneTypeDistPath(outJsName);
         fs.writeFileSync(distDtsPath, tsContent, "utf8");
         fs.writeFileSync(distJsPath, jsContent, "utf8");
         console.log(`Wrote ${distDtsPath}`);

package/dist/scripts/{generateTypesTS.js → generateTypes.js}

@@ -322,9 +322,9 @@ function postProcessEmittedTypes(ts, parsedSchema) {
     return ts;
 }
 // PURE: Add banner + formatting/guards to build the final .d.ts content.
-function finalizeOutputDts(emittedTypesTs) {
+function finalizeOutputDts(emittedType) {
     const banner = '// Auto-generated from JSON schemas. Do not edit.\n';
-    let output = banner + '\n' + emittedTypesTs + '\n';
+    let output = banner + '\n' + emittedType + '\n';
     // Final guard: strip any lingering `[k: string]: unknown;` that might have been
     // reintroduced by later transforms.
     output = output.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*$/gm, '');
@@ -347,8 +347,8 @@ async function main() {
     try {
         const config = getConfig();
         const inputDir = config.getSchemasDir();
-        const srcLibTypesDir = config.getTypesTsSrcDir();
-        const srcLibOutputPath = config.getTypesTsSrcPath('typesTS.d.ts');
+        const srcLibTypesDir = config.getTypesSrcDir();
+        const srcLibOutputPath = config.getTypesSrcPath('types.d.ts');
         fs.mkdirSync(srcLibTypesDir, { recursive: true });
         const schemaFileName = config.getSourceFile();
         const schemaPath = path.join(inputDir, schemaFileName);
@@ -389,8 +389,8 @@ async function main() {
             console.warn('Failed to write types to src/_lib:', e);
         }
         // Also write a copy into dist so consumers get the generated declarations
-        const distLibTypesDir = config.getTypesTsDistDir();
-        const distLibOutputPath = config.getTypesTsDistPath('typesTS.d.ts');
+        const distLibTypesDir = config.getTypesDistDir();
+        const distLibOutputPath = config.getTypesDistPath('types.d.ts');
         try {
             fs.mkdirSync(distLibTypesDir, { recursive: true });
             fs.writeFileSync(distLibOutputPath, output, 'utf8');
@@ -400,26 +400,26 @@ async function main() {
             // If copying to dist fails, log but don't crash the generator.
             console.warn('Failed to write types to dist:', e);
         }
-        // Ensure there is a runtime-resolvable module next to `typesTS.d.ts`
+        // Ensure there is a runtime-resolvable module next to `types.d.ts`
         // Some consumers and TS NodeNext resolution expect a concrete .js next to .d.ts
         // The file is intentionally empty as all exports are types-only.
         try {
-            const srcLibTypesJsPath = config.getTypesTsSrcPath('typesTS.js');
+            const srcLibTypesJsPath = config.getTypesSrcPath('types.js');
             if (!fs.existsSync(srcLibTypesJsPath)) {
                 fs.writeFileSync(srcLibTypesJsPath, 'export {}\n', 'utf8');
                 console.log('Wrote', srcLibTypesJsPath);
             }
         }
         catch (e) {
-            console.warn('Failed to write typesTS.js to src/_lib:', e);
+            console.warn('Failed to write types.js to src/_lib:', e);
         }
         try {
-            const distLibTypesJsPath = config.getTypesTsDistPath('typesTS.js');
+            const distLibTypesJsPath = config.getTypesDistPath('types.js');
             fs.writeFileSync(distLibTypesJsPath, 'export {}\n', 'utf8');
             console.log('Wrote', distLibTypesJsPath);
         }
         catch (e) {
-            console.warn('Failed to write typesTS.js to dist/_lib:', e);
+            console.warn('Failed to write types.js to dist/_lib:', e);
         }
     }
     catch (err) {

package/dist/scripts/normalizeAnchorsToPointers.d.ts

@@ -1 +1 @@
-export {};
+export declare function stripAnchors<T>(schema: T): T;

package/dist/scripts/normalizeAnchorsToPointers.js

@@ -1,18 +1,37 @@
 import fs from 'fs';
 import path from 'path';
 import { getConfig } from './_lib/config.js';
-/**
- * Rewrite anchor-style references to JSON Pointer references in Genesis.json
- *
- * Converts #AnchorName to #/$defs/AnchorName for compatibility with strict
- * JSON Schema validators and downstream tooling. This normalization step runs
- * before both schema extraction and resource envelope generation.
- *
- * The rewritten file is saved under src/genesis/generated/resourceTypes/Genesis.json
- * for use by other scripts.
- *
- * Usage: node ./dist/scripts/normalizeAnchorsToPointers.js
- */
+/*
+    * Rewrite anchor-style references to JSON Pointer references in Genesis.json.
+    * We also strip all $anchor fields from the output since they are no longer needed after rewriting refs.
+*/
+// PURE: Remove all `$anchor` keys from a schema tree without rewriting refs.
+export function stripAnchors(schema) {
+    const seen = new WeakMap();
+    function walk(node) {
+        if (!node || typeof node !== 'object')
+            return node;
+        const existing = seen.get(node);
+        if (existing)
+            return existing;
+        if (Array.isArray(node)) {
+            const out = [];
+            seen.set(node, out);
+            for (const item of node)
+                out.push(walk(item));
+            return out;
+        }
+        const out = {};
+        seen.set(node, out);
+        for (const [key, value] of Object.entries(node)) {
+            if (key === '$anchor')
+                continue;
+            out[key] = walk(value);
+        }
+        return out;
+    }
+    return walk(schema);
+}
 // PURE: Rewrite anchor-style `$ref` strings (`#Anchor`) into JSON Pointer refs (`#/$defs/DefName`).
 function normalizeAnchorsToPointers(input) {
     if (!input || typeof input !== "object")
@@ -90,6 +109,8 @@ function main() {
         }
         // Rewrite anchors in the nucleusSchema (pure function call)
         genesis.nucleusSchema = normalizeAnchorsToPointers(genesis.nucleusSchema);
+        // Strip $anchor fields from the schemas (pure function call)
+        genesis.nucleusSchema = stripAnchors(genesis.nucleusSchema);
         // Write normalized version
         fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
         fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-core/schema",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,12 +34,12 @@
     "normalizeAnchorsToPointers": "node ./dist/scripts/normalizeAnchorsToPointers.js",
     "extractSchemasFromResourceTypeShells": "node ./dist/scripts/extractSchemasFromResourceTypeShells.js",
     "generateStandaloneSchema": "node ./dist/scripts/generateStandaloneSchema.js",
-    "generateTypesTS": "node ./dist/scripts/generateTypesTS.js",
-    "generateStandaloneTypeTS": "node ./dist/scripts/generateStandaloneTypeTS.js",
+    "generateTypes": "node ./dist/scripts/generateTypes.js",
+    "generateStandaloneType": "node ./dist/scripts/generateStandaloneType.js",
     "wrapResourceTypesWithResourceShells": "node ./dist/scripts/wrapResourceTypesWithResourceShells.js",
     "generateSchemaShims": "node ./dist/scripts/generateSchemaShims.js",
     "generateDependencies": "node ./dist/scripts/generateDependencies.js",
-    "generateResourceTypeGenesisType": "node ./dist/scripts/generateStandaloneTypeTS.js --name Genesis",
-    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypesTS && pnpm run generateStandaloneTypeTS -- --name Job && pnpm run generateStandaloneTypeTS -- --name ResourceType && pnpm run generateStandaloneTypeTS -- --name RawStrategy && pnpm run generateStandaloneTypeTS -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run build"
+    "generateResourceTypeGenesisType": "node ./dist/scripts/generateStandaloneType.js --name Genesis",
+    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run normalizeAnchorsToPointers && pnpm run extractSchemasFromResourceTypeShells && pnpm run generateStandaloneSchema -- --name Job && pnpm run generateStandaloneSchema -- --name ResourceType && pnpm run generateStandaloneSchema -- --name RawStrategy && pnpm run generateStandaloneSchema -- --name RunnableStrategy && pnpm run generateStandaloneSchema -- --name StrategyRun && pnpm run generateStandaloneSchema -- --name Goal && pnpm run wrapResourceTypesWithResourceShells && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateStandaloneType -- --name Job && pnpm run generateStandaloneType -- --name ResourceType && pnpm run generateStandaloneType -- --name RawStrategy && pnpm run generateStandaloneType -- --name RunnableStrategy && pnpm run generateResourceTypeGenesisType && pnpm run generateDependencies && pnpm run build"
   }
 }