@toolproof-npm/schema 0.1.46 → 0.1.48

package/dist/genesis/generated/types/Resource_Job.d.ts

@@ -1,56 +1,3 @@
 // Auto-generated strict composite type. Do not edit.
-export type Resource_Job = ResourceMetaBase & {
-  extractedData: Job;
-};
-export type ResourceMetaBase = ResourceBase &
-  CreationContextWrapper &
-  ResourceKind & {
-    kind: "materialized";
-  } & Timestamp &
-  Path;
-export type ResourceBase = {
-  identity: string;
-  resourceTypeRef: string;
-};
-export type Job = {
-  identity: string;
-  implementationUri: string;
-} & Documented &
-  RolesWrapper;
-export type Documented = Named & Described;
-export type ResourceRoleValue = {
-  resourceTypeRef: string;
-} & Documented;
-
-export interface CreationContextWrapper {
-  creationContext: CreationContext;
-}
-export interface CreationContext {
-  executionRef: string;
-  resourceRoleRef: string;
-}
-export interface ResourceKind {
-  kind: "missing" | "potential-input" | "potential-output" | "materialized";
-}
-export interface Timestamp {
-  timestamp: string;
-}
-export interface Path {
-  path: string;
-}
-export interface Named {
-  name: string;
-}
-export interface Described {
-  description: string;
-}
-export interface RolesWrapper {
-  roles: Roles;
-}
-export interface Roles {
-  inputMap: RoleMap;
-  outputMap: RoleMap;
-}
-export interface RoleMap {
-  [k: string]: ResourceRoleValue;
-}
+import type { ResourceMetaBase, Job as ExtractedData } from './types.js';
+export type Resource_Job = ResourceMetaBase & { extractedData: ExtractedData };

package/dist/genesis/generated/types/Resource_ResourceFormat.d.ts

@@ -1,41 +1,3 @@
 // Auto-generated strict composite type. Do not edit.
-export type Resource_ResourceFormat = ResourceMetaBase & {
-  extractedData: ResourceFormat;
-};
-export type ResourceMetaBase = ResourceBase &
-  CreationContextWrapper &
-  ResourceKind & {
-    kind: "materialized";
-  } & Timestamp &
-  Path;
-export type ResourceBase = {
-  identity: string;
-  resourceTypeRef: string;
-};
-export type ResourceFormat = {
-  identity: string;
-} & Documented;
-export type Documented = Named & Described;
-
-export interface CreationContextWrapper {
-  creationContext: CreationContext;
-}
-export interface CreationContext {
-  executionRef: string;
-  resourceRoleRef: string;
-}
-export interface ResourceKind {
-  kind: "missing" | "potential-input" | "potential-output" | "materialized";
-}
-export interface Timestamp {
-  timestamp: string;
-}
-export interface Path {
-  path: string;
-}
-export interface Named {
-  name: string;
-}
-export interface Described {
-  description: string;
-}
+import type { ResourceMetaBase, ResourceFormat as ExtractedData } from './types.js';
+export type Resource_ResourceFormat = ResourceMetaBase & { extractedData: ExtractedData };

package/dist/genesis/generated/types/Resource_ResourceType.d.ts

@@ -1,62 +1,3 @@
 // Auto-generated strict composite type. Do not edit.
-export type Resource_ResourceType = ResourceMetaBase & {
-  extractedData: ResourceType;
-};
-export type ResourceMetaBase = ResourceBase &
-  CreationContextWrapper &
-  ResourceKind & {
-    kind: "materialized";
-  } & Timestamp &
-  Path;
-export type ResourceBase = {
-  identity: string;
-  resourceTypeRef: string;
-};
-export type ResourceType = {
-  identity: string;
-  resourceFormatRef: string;
-} & Documented &
-  ExtractionSchemaWrapper & {
-  };
-export type Documented = Named & Described;
-export type ExtractionSchema = {
-} & {
-  $schema: "https://json-schema.org/draft/2020-12/schema";
-  $defs?: {
-  };
-  type: "object";
-  allOf?: {
-  }[];
-  properties?: {
-  };
-  required?: string[];
-  additionalProperties?: false;
-  unevaluatedProperties?: false;
-  $anchor: string;
-};
-
-export interface CreationContextWrapper {
-  creationContext: CreationContext;
-}
-export interface CreationContext {
-  executionRef: string;
-  resourceRoleRef: string;
-}
-export interface ResourceKind {
-  kind: "missing" | "potential-input" | "potential-output" | "materialized";
-}
-export interface Timestamp {
-  timestamp: string;
-}
-export interface Path {
-  path: string;
-}
-export interface Named {
-  name: string;
-}
-export interface Described {
-  description: string;
-}
-export interface ExtractionSchemaWrapper {
-  extractionSchema: ExtractionSchema;
-}
+import type { ResourceMetaBase, ResourceType as ExtractedData } from './types.js';
+export type Resource_ResourceType = ResourceMetaBase & { extractedData: ExtractedData };

package/dist/genesis/generated/types/Resource_StatelessStrategy.d.ts

@@ -1,80 +1,3 @@
 // Auto-generated strict composite type. Do not edit.
-export type Resource_StatelessStrategy = ResourceMetaBase & {
-  extractedData: StatelessStrategy;
-};
-export type ResourceMetaBase = ResourceBase &
-  CreationContextWrapper &
-  ResourceKind & {
-    kind: "materialized";
-  } & Timestamp &
-  Path;
-export type ResourceBase = {
-  identity: string;
-  resourceTypeRef: string;
-};
-export type StatelessStrategy = {
-  identity: string;
-  steps: Step[];
-};
-export type Step = WorkStep | BranchStep | WhileStep | ForStep;
-export type WorkStep = StepKind & {
-  execution: Execution;
-  identity: string;
-  kind: "work";
-};
-export type Execution = {
-  identity: string;
-  jobRef: string;
-} & RoleBindingsWrapper;
-export type BranchStep = StepKind & {
-  /**
-   * @minItems 1
-   */
-  cases: [Conditional, ...Conditional[]];
-  identity: string;
-  kind: "branch";
-};
-export type WhileStep = StepKind & {
-  case: Conditional;
-  identity: string;
-  kind: "while";
-};
-export type ForStep = StepKind & {
-  case: Conditional;
-  identity: string;
-  kind: "for";
-};
-
-export interface CreationContextWrapper {
-  creationContext: CreationContext;
-}
-export interface CreationContext {
-  executionRef: string;
-  resourceRoleRef: string;
-}
-export interface ResourceKind {
-  kind: "missing" | "potential-input" | "potential-output" | "materialized";
-}
-export interface Timestamp {
-  timestamp: string;
-}
-export interface Path {
-  path: string;
-}
-export interface StepKind {
-  kind: "work" | "branch" | "while" | "for";
-}
-export interface RoleBindingsWrapper {
-  roleBindings: RoleBindings;
-}
-export interface RoleBindings {
-  inputBindingMap: RoleBindingMap;
-  outputBindingMap: RoleBindingMap;
-}
-export interface RoleBindingMap {
-  [k: string]: string;
-}
-export interface Conditional {
-  what: WorkStep;
-  when: WorkStep;
-}
+import type { ResourceMetaBase, StatelessStrategy as ExtractedData } from './types.js';
+export type Resource_StatelessStrategy = ResourceMetaBase & { extractedData: ExtractedData };

package/dist/genesis/generated/types/types.d.ts

@@ -82,13 +82,11 @@ export type ExtractionSchema =
  {
 } & {
   $schema: "https://json-schema.org/draft/2020-12/schema";
-  $defs?: {
-};
+  $defs?: Record<string, unknown>;
   type: "object";
-  allOf?: [{type: "array"; items: {type: "object"}}];
-  properties?: {
-};
-  required?: [{type: "array"; items: {type: "string"}; uniqueItems: true}];
+  allOf?: Array<{[k: string]: unknown}>;
+  properties?: Record<string, unknown>;
+  required?: string[];
   additionalProperties?: false;
   unevaluatedProperties?: false;
   $anchor: string;
@@ -123,7 +121,10 @@ export type IdentitySchema =
   type: "string" | "number" | "integer" | "boolean";
   $anchor?: string;
   $comment?: string;
-  enum?: [{type: "array"; minItems: 1; uniqueItems: true}];
+  /**
+   * @minItems 1
+   */
+  enum?: [unknown, ...unknown[]];
   format?: string;
   maxLength?: number;
   minLength?: number;
@@ -180,7 +181,10 @@ export type MeritSchema =
   type?: "number" | "integer";
   $anchor?: string;
   $comment?: string;
-  enum?: [{type: "array"; items: {type: "number"}; minItems: 1; uniqueItems: true}];
+  /**
+   * @minItems 1
+   */
+  enum?: [number, ...number[]];
   exclusiveMaximum?: number;
   exclusiveMinimum?: number;
   maximum?: number;
@@ -192,7 +196,10 @@ export type MeritSchema1 =
       type: "number" | "integer";
 }
   | {
-      enum: [{type: "array"; items: {type: "number"}; minItems: 1}];
+      /**
+       * @minItems 1
+       */
+      enum: [number, ...number[]];
 };
 /**
  * This interface was referenced by `GenesisJson`'s JSON-Schema
@@ -416,12 +423,11 @@ export interface ExtractionSchemaWrapper {
  * via the `definition` "IdentityProp".
  */
 export interface IdentityProp {
-  $defs: {
-};
+  $defs: Record<string, unknown>;
   properties: {
     identity: IdentitySchemaRef;
 };
-  required?: string[];
+  required: string[];
   additionalProperties?: unknown;
 }
 /**
@@ -456,12 +462,11 @@ export type RoleMap = Record<ResourceRoleIdentity, ResourceRoleValue>;
  * via the `definition` "MeritProp".
  */
 export interface MeritProp {
-  $defs: {
-};
+  $defs: Record<string, unknown>;
   properties: {
     merit: MeritSchemaRef;
 };
-  required: [{type: "array"; items: {type: "string"}; uniqueItems: true}];
+  required: string[];
   additionalProperties?: unknown;
 }
 /**
@@ -577,13 +582,11 @@ export type ExtractionSchema =
  {
 } & {
   $schema: "https://json-schema.org/draft/2020-12/schema";
-  $defs?: {
-};
+  $defs?: Record<string, unknown>;
   type: "object";
-  allOf?: [{type: "array"; items: {type: "object"}}];
-  properties?: {
-};
-  required?: [{type: "array"; items: {type: "string"}; uniqueItems: true}];
+  allOf?: Array<{[k: string]: unknown}>;
+  properties?: Record<string, unknown>;
+  required?: string[];
   additionalProperties?: false;
   unevaluatedProperties?: false;
   $anchor: string;

package/dist/scripts/generateResourceTypeType.js

@@ -1,6 +1,4 @@
 import fs from 'fs';
-import path from 'path';
-import { compileFromFile } from 'json-schema-to-typescript';
 import { getConfig } from './_lib/config.js';
 /**
  * Generate a typed Resource variant where `extractedData` is typed to a specific schema
@@ -15,8 +13,6 @@ async function main() {
         console.error('Missing --name <SchemaBasename> argument');
         process.exit(1);
     }
-    const projectRoot = config.getRoot();
-    const schemasDir = config.getOutputDir();
     const inPath = config.getOutputPath(`${name}.json`);
     if (!fs.existsSync(inPath)) {
         console.error(`Schema file not found: ${inPath}`);
@@ -46,73 +42,33 @@ async function main() {
     const outPath = config.getTypesSrcPath(outName);
     const outJsName = `Resource_${name}.js`;
     const outJsPath = config.getTypesSrcPath(outJsName);
-    // Build a composite schema in output directory so that local $ref paths are simple
-    const schemasOutDir = config.getOutputDir();
-    const compositePath = path.join(schemasOutDir, `.composite.Resource_${name}.json`);
-    const compositeSchema = {
-        $schema: 'https://json-schema.org/draft/2020-12/schema',
-        title: `Resource_${name}`,
-        type: 'object',
-        allOf: [
-            { $ref: `./${config.getSourceFile()}#/$defs/ResourceMetaBase` },
-            {
-                type: 'object',
-                required: ['extractedData'],
-                properties: {
-                    extractedData: { $ref: `./${name}.json` }
-                },
-                unevaluatedProperties: false
-            }
-        ],
-        unevaluatedProperties: false
-    };
-    // Write composite schema
-    fs.writeFileSync(compositePath, JSON.stringify(compositeSchema, null, 2), 'utf8');
-    try {
-        // Compile to TypeScript declarations
-        let ts = await compileFromFile(compositePath, {
-            bannerComment: '',
-            declareExternallyReferenced: true,
-            unreachableDefinitions: true,
-            $refOptions: {
-                resolve: {
-                    file: { order: 1 },
-                    http: false,
-                    https: false
-                }
-            }
-        });
-        // Remove noisy index signatures that make types too permissive
-        ts = ts.replace(/\n\s*\[k:\s*string\]:\s*unknown;\n/g, '\n');
-        // Ensure it is a module
-        if (!/\bexport\b/.test(ts)) {
-            ts += '\nexport {}\n';
-        }
-        const header = '// Auto-generated strict composite type. Do not edit.\n';
-        fs.writeFileSync(outPath, header + ts, 'utf8');
-        console.log(`Wrote ${outPath}`);
-        // Ensure a runtime-resolvable JS shim exists alongside the .d.ts for NodeNext resolution
-        if (!fs.existsSync(outJsPath)) {
-            fs.writeFileSync(outJsPath, 'export {}\n', 'utf8');
-            console.log(`Wrote ${outJsPath}`);
-        }
-        // Also copy both files into dist so consumers can resolve the module and its types
-        const distLibDir = config.getTypesDistDir();
-        fs.mkdirSync(distLibDir, { recursive: true });
-        const distDtsPath = config.getTypesDistPath(outName);
-        const distJsPath = config.getTypesDistPath(outJsName);
-        fs.writeFileSync(distDtsPath, header + ts, 'utf8');
-        fs.writeFileSync(distJsPath, 'export {}\n', 'utf8');
-        console.log(`Wrote ${distDtsPath}`);
-        console.log(`Wrote ${distJsPath}`);
-    }
-    finally {
-        // Cleanup composite schema file
-        try {
-            fs.unlinkSync(compositePath);
-        }
-        catch { }
+    // IMPORTANT:
+    // We intentionally do NOT re-run json-schema-to-typescript here.
+    // That path produces self-contained types that degrade schema-patterned identities/refs
+    // into plain `string`, which then becomes incompatible with our canonical branded
+    // identity types in `types.d.ts` (e.g. `ResourceIdentity = `RESOURCE-${string}``).
+    //
+    // Instead, we generate a tiny module that composes the canonical types:
+    //   Resource_<Name> = ResourceMetaBase & { extractedData: <Name> }
+    const header = '// Auto-generated strict composite type. Do not edit.\n';
+    const ts = `import type { ResourceMetaBase, ${name} as ExtractedData } from './types.js';\n` +
+        `export type Resource_${name} = ResourceMetaBase & { extractedData: ExtractedData };\n`;
+    fs.writeFileSync(outPath, header + ts, 'utf8');
+    console.log(`Wrote ${outPath}`);
+    // Ensure a runtime-resolvable JS shim exists alongside the .d.ts for NodeNext resolution
+    if (!fs.existsSync(outJsPath)) {
+        fs.writeFileSync(outJsPath, 'export {}\n', 'utf8');
+        console.log(`Wrote ${outJsPath}`);
     }
+    // Also copy both files into dist so consumers can resolve the module and its types
+    const distLibDir = config.getTypesDistDir();
+    fs.mkdirSync(distLibDir, { recursive: true });
+    const distDtsPath = config.getTypesDistPath(outName);
+    const distJsPath = config.getTypesDistPath(outJsName);
+    fs.writeFileSync(distDtsPath, header + ts, 'utf8');
+    fs.writeFileSync(distJsPath, 'export {}\n', 'utf8');
+    console.log(`Wrote ${distDtsPath}`);
+    console.log(`Wrote ${distJsPath}`);
 }
 function parseArgs(args) {
     let name;

package/dist/scripts/generateTypes.js

@@ -187,24 +187,38 @@ async function main() {
             try {
                 const rawSchema = fs.readFileSync(schemaPath, 'utf8');
                 const parsedSchema = JSON.parse(rawSchema);
-                function normalizeArrays(node) {
+                function normalizeArrays(node, parentKey) {
                     if (Array.isArray(node)) {
                         for (let i = 0; i < node.length; i++)
-                            normalizeArrays(node[i]);
+                            normalizeArrays(node[i], parentKey);
                         return;
                     }
                     if (!node || typeof node !== 'object')
                         return;
-                    const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
-                    for (const k of arrayKeys) {
-                        if (k in node) {
-                            const v = node[k];
-                            if (!Array.isArray(v))
-                                node[k] = [v];
+                    // IMPORTANT:
+                    // In meta-schemas we often have `properties: { required: { ...schema... } }`.
+                    // Here, the key "required" is a *property name*, not the JSON-Schema keyword
+                    // "required". Blindly normalizing would wrap that schema object into an array,
+                    // causing json-schema-to-typescript to emit the schema-shape instead of `string[]`.
+                    //
+                    // So: only coerce array-keywords when we're not inside a map of property names.
+                    const isPropertyNameMap = parentKey === 'properties'
+                        || parentKey === 'patternProperties'
+                        || parentKey === '$defs'
+                        || parentKey === 'definitions'
+                        || parentKey === 'dependentSchemas';
+                    if (!isPropertyNameMap) {
+                        const arrayKeys = ['anyOf', 'allOf', 'oneOf', 'required', 'enum'];
+                        for (const k of arrayKeys) {
+                            if (k in node) {
+                                const v = node[k];
+                                if (!Array.isArray(v))
+                                    node[k] = [v];
+                            }
                         }
                     }
-                    for (const val of Object.values(node))
-                        normalizeArrays(val);
+                    for (const [k, v] of Object.entries(node))
+                        normalizeArrays(v, k);
                 }
                 // Normalize expected arrays to prevent traversal crashes
                 normalizeArrays(parsedSchema);
@@ -245,15 +259,24 @@ async function main() {
         // Robust single-pass: delete the entire line (with optional trailing newline) where the signature appears.
         // This avoids introducing extra blank lines while handling CRLF/LF and varying indentation.
         ts = ts.replace(/^\s*\[k:\s*string\]:\s*unknown;\s*(?:\r?\n)?/gm, '');
-        // Fix meta-schema types where json-schema-to-typescript incorrectly interprets
-        // schema definitions as literal values. ExtractionSchemaValue describes what
-        // an extraction schema looks like, not what the schema meta-properties should be.
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(\$defs\?:\s*\{[\s\S]*?};)/gm, '$1$defs?: {\n    [k: string]: unknown;\n  };');
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(properties\?:\s*\{[\s\S]*?};)/gm, '$1properties?: {\n    [k: string]: unknown;\n  };');
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(allOf\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"object"\}\}\];)/gm, '$1allOf?: Array<{[k: string]: unknown}>;');
-        ts = ts.replace(/^(export type ExtractionSchemaValue =[\s\S]*?)(required\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
-        // Similarly fix IdentityProp which has the same issue
+        // Fix meta-schema types where json-schema-to-typescript can still incorrectly interpret
+        // schema definitions as literal values (or emit overly-restrictive `{}` objects).
+        // We do this as a broad post-pass on the emitted TS because the generator output varies
+        // (e.g. `allOf?: { }[];` vs `allOf?: [{type:"array"; ...}]`).
+        // `$defs?: { }` or `$defs: { }` -> map type (preserve required/optional marker)
+        // NOTE: We emit `Record<...>` instead of an index signature because later cleanup
+        // strips standalone `[k: string]: unknown;` lines.
+        ts = ts.replace(/^(\s*)(\$defs\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+        // `properties?: { }` or `properties: { }` -> map type
+        ts = ts.replace(/^(\s*)(properties\??:\s*)\{\s*\r?\n\s*\};/gm, (_m, indent, head) => `${indent}${head}Record<string, unknown>;`);
+        // `allOf?: { }[];` (and similar for anyOf/oneOf) -> array of schema-ish objects
+        ts = ts.replace(/^(\s*)((?:allOf|anyOf|oneOf)\??:\s*)\{\s*\r?\n\s*\}\[\];/gm, (_m, indent, head) => `${indent}${head}Array<{[k: string]: unknown}>;`);
+        // Older broken shapes from earlier normalization (keep for backwards compatibility)
+        ts = ts.replace(/((?:allOf|anyOf|oneOf)\??:\s*)\[\{type:\s*"array";\s*items:\s*\{type:\s*"object"\}\}\];/g, '$1Array<{[k: string]: unknown}>;');
+        ts = ts.replace(/required\?:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];/g, 'required?: string[];');
+        // Similarly fix IdentityProp/MeritProp which have the same issue
         ts = ts.replace(/^(export interface IdentityProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*contains:\s*\{const:\s*"identity"\};\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
+        ts = ts.replace(/^(export interface MeritProp[\s\S]*?)(required:\s*\[\{type:\s*"array";\s*items:\s*\{type:\s*"string"\};\s*uniqueItems:\s*true\}\];)/gm, '$1required?: string[];');
         // Prune verbose type/interface names produced from absolute $id URLs.
         // Deterministic pruning based on original $id -> baseName map
         // This avoids heuristic truncation that dropped prefixes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/schema",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "JSON schemas and TypeScript types for ToolProof",
   "keywords": [
     "toolproof",