@toolproof-npm/schema 0.1.12

package/dist/schemas/Job.d.ts

@@ -0,0 +1,2 @@
+import schema from './Job.json';
+export default schema;

package/dist/schemas/Job.js

@@ -0,0 +1,2 @@
+import schema from './Job.json' with { type: 'json' };
+export default schema;

package/dist/schemas/Job.json

@@ -0,0 +1,161 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "allOf": [
+        {
+            "$ref": "#/$defs/Documented"
+        },
+        {
+            "$ref": "#/$defs/RolesOuter"
+        },
+        {
+            "$ref": "#/$defs/Uri"
+        }
+    ],
+    "properties": {
+        "identity": {
+            "type": "string"
+        }
+    },
+    "required": [
+        "identity"
+    ],
+    "unevaluatedProperties": false,
+    "$anchor": "Job",
+    "$defs": {
+        "Documented": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "allOf": [
+                {
+                    "$ref": "#/$defs/Name"
+                },
+                {
+                    "$ref": "#/$defs/Description"
+                }
+            ],
+            "$anchor": "Documented"
+        },
+        "RolesOuter": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "roles": {
+                    "$ref": "#/$defs/RolesInner"
+                }
+            },
+            "required": [
+                "roles"
+            ],
+            "$anchor": "RolesOuter"
+        },
+        "Uri": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "uri": {
+                    "type": "string",
+                    "format": "uri"
+                }
+            },
+            "required": [
+                "uri"
+            ],
+            "$anchor": "Uri"
+        },
+        "Name": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string",
+                    "$comment": "Validation is intercepted by an AI Agent that verifies the name against Toolproof's naming conventions.",
+                    "minLength": 1,
+                    "pattern": "^(?:[A-Z].*|[a-z]+/[a-z0-9.+-]+)$",
+                    "semanticValidation": "Ajv custom keyword to verify name."
+                }
+            },
+            "required": [
+                "name"
+            ],
+            "$anchor": "Name"
+        },
+        "Description": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "description": {
+                    "type": "string",
+                    "$comment": "Validation is intercepted by an AI Agent that verifies the description against Toolproof's documentation standards.",
+                    "minLength": 1,
+                    "semanticValidation": "Ajv custom keyword to verify description."
+                }
+            },
+            "required": [
+                "description"
+            ],
+            "$anchor": "Description"
+        },
+        "RolesInner": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+                "inputMap": {
+                    "$ref": "#/$defs/RoleMap"
+                },
+                "outputMap": {
+                    "$ref": "#/$defs/RoleMap"
+                }
+            },
+            "required": [
+                "inputMap",
+                "outputMap"
+            ],
+            "unevaluatedProperties": false,
+            "$anchor": "RolesInner"
+        },
+        "RoleMap": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "additionalProperties": {
+                "$ref": "#/$defs/RoleLiteral"
+            },
+            "$anchor": "RoleMap",
+            "propertyNames": {
+                "$ref": "#/$defs/RoleId"
+            }
+        },
+        "RoleLiteral": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "allOf": [
+                {
+                    "properties": {
+                        "typeId": {
+                            "$ref": "#/$defs/TypeId"
+                        }
+                    },
+                    "required": [
+                        "typeId"
+                    ]
+                },
+                {
+                    "$ref": "#/$defs/Documented"
+                }
+            ],
+            "$anchor": "RoleLiteral"
+        },
+        "RoleId": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "$anchor": "RoleId",
+            "pattern": "^ROLE-.+$"
+        },
+        "TypeId": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "string",
+            "$anchor": "TypeId",
+            "pattern": "^TYPE-.+$"
+        }
+    }
+}

package/dist/scripts/brandFactories.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutionId, ResourceId, WorkStepId, BranchStepId, ForStepId, FormatId, TypeId, RoleId, WhileStepId, WorkflowId, WorkflowSpecId } from "../_lib/types/types.js";
+/** Generic unsafe brand helper when a bespoke factory is not available. */
+export declare function unsafeBrand<T extends string>(s: string): T;
+export declare const asTypeId: (s: string) => `TYPE-${string}`;
+export declare const asRoleId: (s: string) => `ROLE-${string}`;
+export declare const asExecutionId: (s: string) => `EXECUTION-${string}`;
+export declare const asResourceId: (s: string) => `RESOURCE-${string}`;
+export declare const asWorkStepId: (s: string) => `WORKSTEP-${string}`;
+export declare const asBranchStepId: (s: string) => `BRANCHSTEP-${string}`;
+export declare const asForStepId: (s: string) => `FORSTEP-${string}`;
+export declare const asFormatId: (s: string) => `FORMAT-${string}`;
+export declare const asWhileStepId: (s: string) => `WHILESTEP-${string}`;
+export declare const asWorkflowId: (s: string) => `WORKFLOW-${string}`;
+export declare const asWorkflowSpecId: (s: string) => `WORKFLOWSPEC-${string}`;
+export declare const asTypeIds: (xs: string[]) => TypeId[];
+export declare const asRoleIds: (xs: string[]) => RoleId[];
+export declare const asExecutionIds: (xs: string[]) => ExecutionId[];
+export declare const asResourceIds: (xs: string[]) => ResourceId[];
+export declare const asWorkStepIds: (xs: string[]) => WorkStepId[];
+export declare const asBranchStepIds: (xs: string[]) => BranchStepId[];
+export declare const asForStepIds: (xs: string[]) => ForStepId[];
+export declare const asFormatIds: (xs: string[]) => FormatId[];
+export declare const asWhileStepIds: (xs: string[]) => WhileStepId[];
+export declare const asWorkflowIds: (xs: string[]) => WorkflowId[];
+export declare const asWorkflowSpecIds: (xs: string[]) => WorkflowSpecId[];

package/dist/scripts/brandFactories.js

@@ -0,0 +1,50 @@
+// Runtime factories for branded ID string types.
+// Note: The branded types are declared in src/types/types.d.ts by the generator.
+// We import them as type-only so there is no runtime dependency on the .d.ts file.
+// Optional runtime validation toggle. Off by default.
+// Enable by setting TP_BRAND_VALIDATE=1 (or NODE_ENV=development) when running.
+const shouldValidate = (typeof process !== "undefined" && !!process.env &&
+    (process.env.TP_BRAND_VALIDATE === "1" || process.env.NODE_ENV === "development")) ||
+    false;
+function makeFactory(name, pattern) {
+    return (s) => {
+        if (shouldValidate && pattern && !pattern.test(s)) {
+            throw new TypeError(`Invalid ${name}: "${s}" does not match ${String(pattern)}`);
+        }
+        return s;
+    };
+}
+/** Generic unsafe brand helper when a bespoke factory is not available. */
+export function unsafeBrand(s) {
+    return s;
+}
+// Known patterns from schemas (when available)
+const RE_TYPE_ID = /^TYPE-.+$/;
+const RE_SIGNATURE_ID = /^SIGNATURE-.+$/;
+const RE_JOB_ID = /^JOB-.+$/;
+const RE_ROLE_ID = /^ROLE-.+$/;
+// Factories for each Id-like type
+export const asTypeId = makeFactory("TypeId", RE_TYPE_ID);
+export const asRoleId = makeFactory("RoleId", RE_ROLE_ID);
+// IDs without strict regex patterns in the current schemas: keep unchecked casts.
+export const asExecutionId = makeFactory("ExecutionId");
+export const asResourceId = makeFactory("ResourceId");
+export const asWorkStepId = makeFactory("WorkStepId");
+export const asBranchStepId = makeFactory("BranchStepId");
+export const asForStepId = makeFactory("ForStepId");
+export const asFormatId = makeFactory("FormatId");
+export const asWhileStepId = makeFactory("WhileStepId");
+export const asWorkflowId = makeFactory("WorkflowId");
+export const asWorkflowSpecId = makeFactory("WorkflowSpecId");
+// Batch helpers
+export const asTypeIds = (xs) => xs.map(asTypeId);
+export const asRoleIds = (xs) => xs.map(asRoleId);
+export const asExecutionIds = (xs) => xs.map(asExecutionId);
+export const asResourceIds = (xs) => xs.map(asResourceId);
+export const asWorkStepIds = (xs) => xs.map(asWorkStepId);
+export const asBranchStepIds = (xs) => xs.map(asBranchStepId);
+export const asForStepIds = (xs) => xs.map(asForStepId);
+export const asFormatIds = (xs) => xs.map(asFormatId);
+export const asWhileStepIds = (xs) => xs.map(asWhileStepId);
+export const asWorkflowIds = (xs) => xs.map(asWorkflowId);
+export const asWorkflowSpecIds = (xs) => xs.map(asWorkflowSpecId);

package/dist/scripts/extractSchemas.d.ts

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

package/dist/scripts/extractSchemas.js

@@ -0,0 +1,173 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function parseArgs() {
+    const argv = process.argv.slice(2);
+    let inPath = "";
+    let outPath = "";
+    let topLevelId;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--in" && i + 1 < argv.length)
+            inPath = argv[++i];
+        else if (a === "--out" && i + 1 < argv.length)
+            outPath = argv[++i];
+        else if (a === "--id" && i + 1 < argv.length)
+            topLevelId = argv[++i];
+    }
+    if (!inPath || !outPath) {
+        console.error("Usage: node extractSchemas.js --in <Genesis.json> --out <flattened.json> [--id <schemaId>]");
+        process.exit(1);
+    }
+    // Resolve to absolute paths from project root
+    const cwd = process.cwd();
+    const wasInRelative = !path.isAbsolute(inPath);
+    const wasOutRelative = !path.isAbsolute(outPath);
+    if (wasInRelative)
+        inPath = path.join(cwd, inPath);
+    if (wasOutRelative)
+        outPath = path.join(cwd, outPath);
+    // Fallback: resolve relative to script directory if not found
+    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+    if (!fs.existsSync(inPath) && wasInRelative)
+        inPath = path.resolve(scriptDir, inPath);
+    const outDir = path.dirname(outPath);
+    if (!fs.existsSync(outDir) && wasOutRelative) {
+        // Try making directory relative to script dir
+        const altOut = path.resolve(scriptDir, outPath);
+        const altOutDir = path.dirname(altOut);
+        if (!fs.existsSync(path.dirname(outPath))) {
+            // Prefer creating outDir at cwd location if possible; otherwise fallback below when writing
+        }
+        else {
+            outPath = altOut;
+        }
+    }
+    return { inPath, outPath, topLevelId };
+}
+// Heuristic: determine if a node is a Type envelope
+function isTypeEnvelope(node) {
+    return (node && typeof node === "object" && !Array.isArray(node) &&
+        typeof node.id === "string" && node.name && node.extractionSchema && typeof node.extractionSchema === "object");
+}
+// Merge $defs into target, without overwriting existing keys unless identical
+function mergeDefs(target, source, label) {
+    if (!source || typeof source !== "object")
+        return;
+    const src = source["$defs"];
+    if (!src || typeof src !== "object")
+        return;
+    for (const [k, v] of Object.entries(src)) {
+        if (!(k in target)) {
+            target[k] = v;
+        }
+        else {
+            // Best-effort: if duplicate key, require structural equality; otherwise, namespace
+            const existing = JSON.stringify(target[k]);
+            const incoming = JSON.stringify(v);
+            if (existing !== incoming) {
+                const altKey = `${k}__from_${(label || "defs").replace(/[^A-Za-z0-9_]+/g, "_")}`;
+                if (!(altKey in target))
+                    target[altKey] = v;
+            }
+        }
+    }
+}
+// Deeply traverse an object replacing any Type envelope with its extractionSchema,
+// and hoist its inner $defs to topDefs. Prevent infinite recursion with a visited set.
+function unwrapTypes(node, topDefs, labelPath = [], visited = new Set()) {
+    if (node && typeof node === "object") {
+        if (visited.has(node))
+            return node; // avoid cycles
+        visited.add(node);
+    }
+    if (isTypeEnvelope(node)) {
+        const env = node;
+        const inner = env.extractionSchema;
+        // Hoist inner $defs before stripping
+        mergeDefs(topDefs, inner, labelPath.join("_"));
+        // Return the inner schema itself, after also unwrapping any nested envelopes it may contain
+        const unwrappedInner = unwrapTypes(inner, topDefs, labelPath.concat([String(env.id || "env")]), visited);
+        return unwrappedInner;
+    }
+    if (Array.isArray(node)) {
+        return node.map((v, i) => unwrapTypes(v, topDefs, labelPath.concat([String(i)]), visited));
+    }
+    if (node && typeof node === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(node)) {
+            if (k === "$defs" && v && typeof v === "object" && !Array.isArray(v)) {
+                // Process nested $defs: unwrap each entry value if it's a Type envelope
+                const defsOut = {};
+                for (const [dk, dv] of Object.entries(v)) {
+                    const unwrapped = unwrapTypes(dv, topDefs, labelPath.concat(["$defs", dk]), visited);
+                    defsOut[dk] = unwrapped;
+                }
+                out[k] = defsOut;
+            }
+            else {
+                out[k] = unwrapTypes(v, topDefs, labelPath.concat([k]), visited);
+            }
+        }
+        return out;
+    }
+    return node;
+}
+function main() {
+    const { inPath, outPath, topLevelId } = parseArgs();
+    const raw = fs.readFileSync(inPath, "utf8");
+    const doc = JSON.parse(raw);
+    if (!doc || typeof doc !== "object" || !doc.extractionSchema) {
+        throw new Error("Input must be a Type JSON with an extractionSchema at the top level");
+    }
+    const topSchema = doc.extractionSchema;
+    const outDefs = {};
+    // Seed with top-level $defs (if any) before unwrapping
+    mergeDefs(outDefs, topSchema, "top");
+    // Unwrap the entire top schema tree so that any nested Type envelopes become raw schemas
+    const flattened = unwrapTypes(topSchema, outDefs, ["extractionSchema"]);
+    // Assemble output: force $schema, optionally set $id, hoist collected $defs
+    let base;
+    if (flattened && typeof flattened === "object" && !Array.isArray(flattened)) {
+        base = { ...flattened };
+    }
+    else {
+        // If flattened is not an object (should be rare for a top-level schema), wrap it
+        base = { const: flattened };
+    }
+    const output = {
+        $schema: "https://json-schema.org/draft/2020-12/schema",
+        ...(topLevelId ? { $id: topLevelId } : {}),
+        ...base,
+    };
+    // Merge collected defs into output.$defs, taking care not to clobber any existing
+    if (!("$defs" in output))
+        output.$defs = {};
+    const finalDefs = output.$defs || {};
+    for (const [k, v] of Object.entries(outDefs)) {
+        if (!(k in finalDefs))
+            finalDefs[k] = v;
+    }
+    output.$defs = finalDefs;
+    // Ensure a stable order for readability
+    const ordered = orderKeys(output, ["$id", "$schema", "$vocabulary", "$defs", "title", "description", "type", "allOf", "anyOf", "oneOf", "not", "if", "then", "else", "properties", "required", "additionalProperties", "unevaluatedProperties"]);
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    fs.writeFileSync(outPath, JSON.stringify(ordered, null, 4), "utf8");
+    console.log(`Wrote flattened schema to ${outPath}`);
+}
+function orderKeys(obj, preferred) {
+    if (Array.isArray(obj))
+        return obj.map((v) => orderKeys(v, preferred));
+    if (!obj || typeof obj !== "object")
+        return obj;
+    const keys = Object.keys(obj);
+    const sorted = [
+        ...preferred.filter((k) => keys.includes(k)),
+        ...keys.filter((k) => !preferred.includes(k)).sort()
+    ];
+    const out = {};
+    for (const k of sorted)
+        out[k] = orderKeys(obj[k], preferred);
+    return out;
+}
+main();

package/dist/scripts/extractSubschemaWithDefs.d.ts

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

package/dist/scripts/extractSubschemaWithDefs.js

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * Generic extractor: given a subschema name that exists under Genesis.json $defs,
+ * produce a standalone JSON Schema file that contains that subschema plus an inner $defs
+ * object holding all direct & transitive local $defs dependencies (by #/$defs/... $ref).
+ *
+ * Genesis.json itself is left unchanged.
+ *
+ * Usage:
+ *   node ./dist/scripts/extractSubschemaWithDefs.js --name <DefName>
+ *
+ * Writes: src/schemas/<DefName>.json
+ */
+async function main() {
+    const { name } = parseArgs(process.argv.slice(2));
+    if (!name) {
+        console.error('Missing --name <DefName> argument');
+        process.exit(1);
+    }
+    const projectRoot = process.cwd();
+    const schemasDir = path.join(projectRoot, 'src', 'schemas');
+    const genesisPath = path.join(schemasDir, 'Genesis.json');
+    const outPath = path.join(schemasDir, `${name}.json`);
+    if (!fs.existsSync(genesisPath)) {
+        console.error(`Genesis.json not found at ${genesisPath}`);
+        process.exit(1);
+    }
+    const raw = fs.readFileSync(genesisPath, 'utf-8');
+    const genesis = JSON.parse(raw);
+    const rootDefs = genesis.$defs;
+    if (!rootDefs || typeof rootDefs !== 'object') {
+        console.error('No $defs object found in Genesis.json');
+        process.exit(1);
+    }
+    const target = rootDefs[name];
+    if (!target) {
+        console.error(`Subschema named '${name}' not found under $defs in Genesis.json`);
+        process.exit(1);
+    }
+    // Collect transitive local $defs names referenced by target
+    const needed = collectLocalDefClosure(target, rootDefs);
+    // Build output schema: clone target and attach collected subset as $defs
+    const targetClone = deepClone(target);
+    const defsOut = {};
+    for (const defName of needed) {
+        // Avoid including the target itself inside its own $defs (mirrors previous pattern)
+        if (defName === name)
+            continue;
+        const defSchema = rootDefs[defName];
+        if (defSchema === undefined) {
+            console.error(`Warning: referenced def '${defName}' missing in root $defs (skipped).`);
+            continue;
+        }
+        defsOut[defName] = deepClone(defSchema);
+    }
+    // Merge any pre-existing inner $defs of targetClone (if present) giving precedence to collected ones
+    const existingInner = isObject(targetClone.$defs) ? targetClone.$defs : {};
+    targetClone.$defs = { ...existingInner, ...defsOut };
+    fs.writeFileSync(outPath, JSON.stringify(targetClone, null, 2) + '\n');
+    console.log(`Extracted subschema '${name}' with ${needed.size} transitive local defs -> ${outPath}`);
+}
+// ---- Helpers ----
+function parseArgs(args) {
+    let name;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--name') {
+            name = args[i + 1];
+            i++;
+        }
+        else if (a.startsWith('--name=')) {
+            name = a.split('=')[1];
+        }
+    }
+    return { name };
+}
+function isObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function deepClone(v) {
+    if (Array.isArray(v))
+        return v.map((x) => deepClone(x));
+    if (isObject(v)) {
+        const out = {};
+        for (const k of Object.keys(v))
+            out[k] = deepClone(v[k]);
+        return out;
+    }
+    return v;
+}
+function extractLocalDefName(ref) {
+    // Accept refs like '#/$defs/Name' only (single-level under $defs)
+    if (!ref || !ref.startsWith('#/'))
+        return null;
+    const parts = ref.slice(2).split('/'); // remove '#/'
+    if (parts.length !== 2)
+        return null;
+    if (parts[0] !== '$defs')
+        return null;
+    // Decode JSON Pointer tokens for the def name
+    const name = parts[1].replace(/~1/g, '/').replace(/~0/g, '~');
+    return name;
+}
+function collectLocalDefClosure(node, rootDefs) {
+    const needed = new Set();
+    const queue = [];
+    function visit(n) {
+        if (Array.isArray(n)) {
+            for (const item of n)
+                visit(item);
+            return;
+        }
+        if (!isObject(n))
+            return;
+        if (typeof n.$ref === 'string') {
+            const name = extractLocalDefName(n.$ref);
+            if (name && !needed.has(name)) {
+                needed.add(name);
+                queue.push(name);
+            }
+        }
+        for (const val of Object.values(n))
+            visit(val);
+    }
+    visit(node);
+    while (queue.length > 0) {
+        const name = queue.shift();
+        const def = rootDefs[name];
+        if (!def)
+            continue; // Missing def handled earlier
+        visit(def);
+    }
+    return needed;
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/scripts/generateResourceData.d.ts

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