@toolproof-npm/schema 0.1.51 → 0.1.53

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { default as GenesisSchema } from './genesis/generated/schemas/Genesis.js';
-export { default as Genesis } from './genesis/resourceTypes/Genesis.js';
+export { default as GenesisResourceType } from './genesis/generated/resource-type-envelopes/Genesis.js';
 export { default as JobSchema } from './genesis/generated/schemas/Job.js';
 export type { Resource_ResourceFormat as Resource_ResourceFormatJson } from './genesis/generated/types/Resource_ResourceFormat.js';
 export type { Resource_ResourceType as Resource_ResourceTypeJson } from './genesis/generated/types/Resource_ResourceType.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 // Re-export JSON schemas via .ts shims to avoid .json re-exports in declarations
 export { default as GenesisSchema } from './genesis/generated/schemas/Genesis.js';
-export { default as Genesis } from './genesis/resourceTypes/Genesis.js';
+export { default as GenesisResourceType } from './genesis/generated/resource-type-envelopes/Genesis.js';
 export { default as JobSchema } from './genesis/generated/schemas/Job.js';
 // Re-export brand factories so consumers can construct branded identities at runtime.
 export { unsafeBrand, asResourceTypeIdentity, asResourceRoleIdentity, asExecutionIdentity, asResourceIdentity, asWorkStepIdentity, asBranchStepIdentity, asForStepIdentity, asResourceFormatIdentity, asWhileStepIdentity, asStatelessStrategyIdentity, asStatefulStrategyIdentity, asResourceTypeIdentities, asResourceRoleIdentities, asExecutionIdentities, asResourceIdentities, asWorkStepIdentities, asBranchStepIdentities, asForStepIdentities, asResourceFormatIdentities, asWhileStepIdentities, asStatelessStrategyIdentities, asStatefulStrategyIdentities, } from './scripts/brandFactories.js';

package/dist/scripts/_lib/config.d.ts

@@ -10,6 +10,7 @@ export declare class SchemaConfig {
     private readonly root;
     private readonly sourceDir;
     private readonly sourceFile;
+    private readonly normalizedDir;
     private readonly outputDir;
     private readonly typesSrcDir;
     private readonly typesDistDir;
@@ -20,6 +21,9 @@ export declare class SchemaConfig {
     getSourceDir(): string;
     getSourceFile(): string;
     getSourcePath(): string;
+    getNormalizedDir(): string;
+    getNormalizedSourceFile(): string;
+    getNormalizedSourcePath(): string;
     getOutputDir(): string;
     getOutputPath(filename: string): string;
     getTypesSrcDir(): string;

package/dist/scripts/_lib/config.js

@@ -18,8 +18,11 @@ export class SchemaConfig {
     constructor() {
         // Environment variables with sensible defaults
         this.root = getEnv('TP_SCHEMA_ROOT', process.cwd());
-        this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/genesis/resourceTypes');
+        this.sourceDir = getEnv('TP_SCHEMA_SOURCE_DIR', 'src/genesis');
         this.sourceFile = getEnv('TP_SCHEMA_SOURCE_FILE', 'Genesis.json');
+        // Intermediate, generated artifact produced by rewriteAnchors.
+        // This should NOT live next to the source-of-truth schemas.
+        this.normalizedDir = getEnv('TP_SCHEMA_NORMALIZED_DIR', 'src/genesis/generated/resourceTypes');
         this.outputDir = getEnv('TP_SCHEMA_OUTPUT_DIR', 'src/genesis/generated/schemas');
         this.typesSrcDir = getEnv('TP_SCHEMA_TYPES_SRC_DIR', 'src/genesis/generated/types');
         this.typesDistDir = getEnv('TP_SCHEMA_TYPES_DIST_DIR', 'dist/genesis/generated/types');
@@ -41,6 +44,20 @@ export class SchemaConfig {
     getSourcePath() {
         return path.join(this.getSourceDir(), this.sourceFile);
     }
+    getNormalizedDir() {
+        return path.isAbsolute(this.normalizedDir)
+            ? this.normalizedDir
+            : path.join(this.root, this.normalizedDir);
+    }
+    getNormalizedSourceFile() {
+        // We keep the same basename (Genesis.json) in the generated folder.
+        // The source-of-truth Genesis.json lives under `TP_SCHEMA_SOURCE_DIR`.
+        // The generated/normalized Genesis.json lives under `TP_SCHEMA_NORMALIZED_DIR`.
+        return this.sourceFile;
+    }
+    getNormalizedSourcePath() {
+        return path.join(this.getNormalizedDir(), this.getNormalizedSourceFile());
+    }
     getOutputDir() {
         return path.isAbsolute(this.outputDir)
             ? this.outputDir

package/dist/scripts/extractSchemas.js

@@ -25,8 +25,8 @@ function parseArgs() {
     }
     // Use config defaults if not provided via CLI
     if (!inPath) {
-        // Use normalized version with anchor refs rewritten to pointers
-        inPath = config.getSourcePath().replace('.json', '.normalized.json');
+        // Use generated/normalized version with anchor refs rewritten to pointers
+        inPath = config.getNormalizedSourcePath();
     }
     if (!outPath) {
         outPath = config.getOutputPath(config.getSourceFile());

package/dist/scripts/generateGenesisResourceTypeType.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/generateGenesisResourceTypeType.js

@@ -0,0 +1,71 @@
+import fs from 'fs';
+import { getConfig } from './_lib/config.js';
+/**
+ * Generates a TS type mapping Genesis $defs names -> ResourceType.
+ *
+ * Output:
+ * - src/genesis/generated/types/GenesisResourceType.d.ts
+ * - dist/genesis/generated/types/GenesisResourceType.d.ts
+ */
+async function main() {
+    const config = getConfig();
+    const genesisPath = config.getSourcePath();
+    if (!fs.existsSync(genesisPath)) {
+        console.error(`Genesis file not found: ${genesisPath}`);
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(genesisPath, 'utf8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        console.error(`Failed to parse JSON: ${genesisPath}`, e);
+        process.exit(1);
+    }
+    const defs = parsed?.extractionSchema?.$defs;
+    if (!defs || typeof defs !== 'object' || Array.isArray(defs)) {
+        console.error(`Expected extractionSchema.$defs to be an object in: ${genesisPath}`);
+        process.exit(1);
+    }
+    const defNames = Object.keys(defs).sort((a, b) => a.localeCompare(b));
+    if (defNames.length === 0) {
+        console.error(`No $defs found at extractionSchema.$defs in: ${genesisPath}`);
+        process.exit(1);
+    }
+    const header = '// Auto-generated from src/genesis/Genesis.json. Do not edit.\n';
+    const importLine = "import type { ResourceType } from './types.js';\n\n";
+    const lines = [];
+    lines.push('export type GenesisResourceType = {');
+    for (const name of defNames) {
+        // Use a string-literal key to handle any non-identifier $defs names safely.
+        lines.push(`  ${JSON.stringify(name)}: ResourceType;`);
+    }
+    lines.push('};\n');
+    const outName = 'GenesisResourceType.d.ts';
+    // Write to src
+    const srcOutDir = config.getTypesSrcDir();
+    fs.mkdirSync(srcOutDir, { recursive: true });
+    const srcOutPath = config.getTypesSrcPath(outName);
+    fs.writeFileSync(srcOutPath, header + importLine + lines.join('\n'), 'utf8');
+    console.log(`Wrote ${srcOutPath}`);
+    // Ensure a runtime-resolvable JS shim exists for NodeNext module resolution
+    const srcOutJsPath = config.getTypesSrcPath('GenesisResourceType.js');
+    if (!fs.existsSync(srcOutJsPath)) {
+        fs.writeFileSync(srcOutJsPath, 'export {}\n', 'utf8');
+        console.log(`Wrote ${srcOutJsPath}`);
+    }
+    // Also copy into dist (consistent with other generators)
+    const distOutDir = config.getTypesDistDir();
+    fs.mkdirSync(distOutDir, { recursive: true });
+    const distOutPath = config.getTypesDistPath(outName);
+    fs.writeFileSync(distOutPath, header + importLine + lines.join('\n'), 'utf8');
+    console.log(`Wrote ${distOutPath}`);
+    const distOutJsPath = config.getTypesDistPath('GenesisResourceType.js');
+    fs.writeFileSync(distOutJsPath, 'export {}\n', 'utf8');
+    console.log(`Wrote ${distOutJsPath}`);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateResourceEnvelopes.js

@@ -18,7 +18,7 @@ import { getConfig } from './_lib/config.js';
 async function main() {
     const config = getConfig();
     // Use normalized version with anchor refs rewritten to pointers
-    const genesisSourcePath = config.getSourcePath().replace('.json', '.normalized.json');
+    const genesisSourcePath = config.getNormalizedSourcePath();
     const outputPath = path.join(config.getRoot(), 'src', 'genesis', 'generated', 'resources', 'Genesis.json');
     if (!fs.existsSync(genesisSourcePath)) {
         console.error(`Genesis source file not found at ${genesisSourcePath}`);

package/dist/scripts/generateSchemaShims.js

@@ -18,6 +18,7 @@ async function main() {
     const config = getConfig();
     const schemasDir = config.getOutputDir();
     const resourcesDir = path.join(path.dirname(schemasDir), 'resources');
+    const generatedResourceTypesDir = config.getNormalizedDir();
     // Process schemas directory
     let totalCount = 0;
     if (fs.existsSync(schemasDir)) {
@@ -55,6 +56,26 @@ async function main() {
     else {
         console.warn(`Resources directory not found at ${resourcesDir}`);
     }
+    // Genesis (normalized) shim
+    // We treat the normalized Genesis.json under src/genesis/generated/resourceTypes as the
+    // public import target, and generate a shim right next to it.
+    try {
+        const genesisJsonPath = config.getNormalizedSourcePath();
+        if (fs.existsSync(genesisJsonPath)) {
+            fs.mkdirSync(generatedResourceTypesDir, { recursive: true });
+            const outPath = path.join(generatedResourceTypesDir, 'Genesis.ts');
+            const content = `import schema from './Genesis.json' with { type: 'json' };\nexport default schema;\n`;
+            fs.writeFileSync(outPath, content, 'utf-8');
+            console.log(`Generated Genesis.ts in ${generatedResourceTypesDir}`);
+            totalCount++;
+        }
+        else {
+            console.warn(`Genesis source JSON not found at ${genesisJsonPath}; skipping Genesis.ts shim`);
+        }
+    }
+    catch (e) {
+        console.warn('Failed to generate Genesis.ts shim:', e);
+    }
     console.log(`Generated ${totalCount} total TypeScript shims`);
 }
 main().catch((e) => {

package/dist/scripts/generateTypes.js

@@ -220,8 +220,66 @@ async function main() {
                     for (const [k, v] of Object.entries(node))
                         normalizeArrays(v, k);
                 }
+                // json-schema-to-typescript has a long-standing quirk:
+                // when a schema uses `allOf`, sibling object keywords like `properties`/`required`
+                // can be ignored in the emitted TS (it treats `allOf` as the whole schema).
+                //
+                // Example (Genesis $defs/Job):
+                //   { type: 'object', allOf: [Documented, RolesWrapper], properties: { identity: ... }, required: [...] }
+                // can become:
+                //   type Job = Documented & RolesWrapper
+                //
+                // To avoid cluttering the source JSON schemas, we normalize to a temp file:
+                // move those sibling object keywords into an extra `allOf` item.
+                function normalizeAllOfSiblingObjectKeywords(node) {
+                    if (Array.isArray(node)) {
+                        for (const item of node)
+                            normalizeAllOfSiblingObjectKeywords(item);
+                        return;
+                    }
+                    if (!node || typeof node !== 'object')
+                        return;
+                    const hasAllOf = Array.isArray(node.allOf) && node.allOf.length > 0;
+                    const looksLikeObjectSchema = node.type === 'object' ||
+                        node.properties !== undefined ||
+                        node.required !== undefined ||
+                        node.unevaluatedProperties !== undefined ||
+                        node.additionalProperties !== undefined;
+                    if (hasAllOf && looksLikeObjectSchema) {
+                        const siblingKeys = [
+                            'properties',
+                            'required',
+                            'additionalProperties',
+                            'unevaluatedProperties',
+                            'propertyNames',
+                            'patternProperties',
+                            'dependentRequired',
+                            'dependentSchemas',
+                            'minProperties',
+                            'maxProperties'
+                        ];
+                        const hasSiblingObjectKeywords = siblingKeys.some((k) => k in node);
+                        if (hasSiblingObjectKeywords) {
+                            const overlay = {};
+                            if (node.type === 'object')
+                                overlay.type = 'object';
+                            for (const k of siblingKeys) {
+                                if (k in node) {
+                                    overlay[k] = node[k];
+                                    delete node[k];
+                                }
+                            }
+                            // Prepend so it participates in the intersection early.
+                            node.allOf = [overlay, ...node.allOf];
+                        }
+                    }
+                    for (const v of Object.values(node))
+                        normalizeAllOfSiblingObjectKeywords(v);
+                }
                 // Normalize expected arrays to prevent traversal crashes
                 normalizeArrays(parsedSchema);
+                // Normalize `allOf` + sibling object keywords so the TS generator doesn't drop them.
+                normalizeAllOfSiblingObjectKeywords(parsedSchema);
                 const tmpPath = path.join(inputDir, `.normalized.${path.basename(fileName)}`);
                 fs.writeFileSync(tmpPath, JSON.stringify(parsedSchema, null, 2), 'utf8');
                 toCompilePath = tmpPath;

package/dist/scripts/rewriteAnchors.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import path from 'path';
 import { getConfig } from './_lib/config.js';
 /**
  * Rewrite anchor-style references to JSON Pointer references
@@ -65,8 +66,8 @@ function rewriteAnchorsToPointers(root) {
 async function main() {
     const config = getConfig();
     const genesisSourcePath = config.getSourcePath();
-    // Create a temporary normalized version
-    const normalizedPath = genesisSourcePath.replace('.json', '.normalized.json');
+    // Create a generated/normalized version (anchor refs rewritten to pointers)
+    const normalizedPath = config.getNormalizedSourcePath();
     if (!fs.existsSync(genesisSourcePath)) {
         console.error(`Genesis source file not found at ${genesisSourcePath}`);
         process.exit(1);
@@ -81,6 +82,7 @@ async function main() {
     // Rewrite anchors in the extractionSchema (where $defs is at the top level)
     rewriteAnchorsToPointers(genesis.extractionSchema);
     // Write normalized version
+    fs.mkdirSync(path.dirname(normalizedPath), { recursive: true });
     fs.writeFileSync(normalizedPath, JSON.stringify(genesis, null, 4), 'utf-8');
     console.log(`Wrote normalized Genesis with pointer refs to ${normalizedPath}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/schema",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "keywords": [
     "toolproof",
@@ -49,9 +49,10 @@
     "extractSubschema": "node ./dist/scripts/extractSubschemaWithDefs.js",
     "resolveRefsInGenesisStory": "pnpm run build:scripts && node ./dist/scripts/resolveRefsInGenesisStory.js",
     "generateTypes": "node ./dist/scripts/generateTypes.js",
+    "generateGenesisResourceTypeType": "node ./dist/scripts/generateGenesisResourceTypeType.js",
     "generateResourceTypeType": "node ./dist/scripts/generateResourceTypeType.js",
     "generateResourceEnvelopes": "node ./dist/scripts/generateResourceEnvelopes.js",
     "generateSchemaShims": "node ./dist/scripts/generateSchemaShims.js",
-    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run rewriteAnchors && pnpm run generateResourceEnvelopes && pnpm run extractSchemas && pnpm run extractSubschema -- --name Job && pnpm run extractSubschema -- --name ResourceFormat && pnpm run extractSubschema -- --name ResourceType && pnpm run extractSubschema -- --name StatelessStrategy && pnpm run extractSubschema -- --name StatefulStrategy && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateResourceTypeType -- --name Job && pnpm run generateResourceTypeType -- --name ResourceFormat && pnpm run generateResourceTypeType -- --name ResourceType && pnpm run generateResourceTypeType -- --name StatelessStrategy && pnpm run build"
+    "update": "rimraf /s /q dist && pnpm run build:scripts && pnpm run rewriteAnchors && pnpm run generateResourceEnvelopes && pnpm run extractSchemas && pnpm run extractSubschema -- --name Job && pnpm run extractSubschema -- --name ResourceFormat && pnpm run extractSubschema -- --name ResourceType && pnpm run extractSubschema -- --name StatelessStrategy && pnpm run extractSubschema -- --name StatefulStrategy && pnpm run generateSchemaShims && pnpm run generateTypes && pnpm run generateResourceTypeType -- --name Job && pnpm run generateResourceTypeType -- --name ResourceFormat && pnpm run generateResourceTypeType -- --name ResourceType && pnpm run generateResourceTypeType -- --name StatelessStrategy && pnpm run generateGenesisResourceTypeType && pnpm run build"
   }
 }