@archrad/deterministic 0.1.0

package/dist/exportPipeline.js

@@ -0,0 +1,65 @@
+/**
+ * Full deterministic export for Python FastAPI and Node Express (no LLM).
+ * Used by the ArchRad server and the `archrad` CLI.
+ */
+import generatePythonFastAPIFiles from './pythonFastAPI.js';
+import generateNodeExpressFiles from './nodeExpress.js';
+import { applyFastApiGoldenLayer, applyNodeExpressGoldenLayer } from './golden-bundle.js';
+import { validateOpenApiInBundleStructural } from './openapi-structural.js';
+import { normalizeGoldenHostPort } from './hostPort.js';
+import { validateIrStructural, hasIrStructuralErrors, } from './ir-structural.js';
+import { validateIrLint } from './ir-lint.js';
+/**
+ * Generate FastAPI or Express project files + golden Docker/Makefile + OpenAPI **document-shape** check.
+ */
+export async function runDeterministicExport(actualIR, target, opts = {}) {
+    const skipIr = Boolean(opts.skipIrStructuralValidation);
+    const skipLint = Boolean(opts.skipIrLint);
+    let irStructuralFindings = skipIr ? [] : validateIrStructural(actualIR);
+    if (!skipIr && hasIrStructuralErrors(irStructuralFindings)) {
+        return { files: {}, openApiStructuralWarnings: [], irStructuralFindings, irLintFindings: [] };
+    }
+    let irLintFindings = [];
+    if (!skipLint) {
+        const lintPass = validateIrLint(actualIR);
+        if (skipIr) {
+            // Dangerous mode: full structural pass is off, but parse/normalize failures still return IR-STRUCT-* from
+            // validateIrLint — fold those into irStructuralFindings so InkByte / CLI consumers block and log like normal.
+            const structFromLint = lintPass.filter((f) => f.code.startsWith('IR-STRUCT-'));
+            irLintFindings = lintPass.filter((f) => !f.code.startsWith('IR-STRUCT-'));
+            irStructuralFindings = structFromLint;
+            if (hasIrStructuralErrors(irStructuralFindings)) {
+                return { files: {}, openApiStructuralWarnings: [], irStructuralFindings, irLintFindings };
+            }
+        }
+        else {
+            irLintFindings = lintPass;
+        }
+    }
+    const t = String(target || '').toLowerCase();
+    let files = {};
+    const hostPort = normalizeGoldenHostPort(opts.hostPort ?? opts.goldenHostPort ?? process.env.ARCHRAD_HOST_PORT);
+    const goldenOpts = { hostPort };
+    if (t === 'python') {
+        files = await generatePythonFastAPIFiles(actualIR, opts).catch(() => ({}));
+        applyFastApiGoldenLayer(files, goldenOpts);
+    }
+    else if (t === 'node' || t === 'nodejs') {
+        files = await generateNodeExpressFiles(actualIR, opts).catch(() => ({}));
+        applyNodeExpressGoldenLayer(files, goldenOpts);
+    }
+    else {
+        throw new Error(`runDeterministicExport: unsupported target "${target}". Use "python", "node", or "nodejs".`);
+    }
+    const vr = validateOpenApiInBundleStructural(files);
+    const openApiStructuralWarnings = [];
+    if (!vr.ok && vr.path) {
+        for (const e of vr.errors) {
+            openApiStructuralWarnings.push(`${vr.path}: ${e}`);
+        }
+    }
+    else if (!vr.ok) {
+        openApiStructuralWarnings.push(...vr.errors);
+    }
+    return { files, openApiStructuralWarnings, irStructuralFindings, irLintFindings };
+}

package/dist/golden-bundle.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Golden-path assets: IR-aligned OpenAPI is supplied by the caller (deterministic exporter).
+ * This module only applies Docker Compose, Dockerfile, Makefile, README section, and port patches.
+ *
+ * `hostPort` is the machine port (left side of docker publish). Container listens on 8080.
+ */
+export type GoldenLayerOptions = {
+    /** Host port for `docker compose` publish (default 8080). Container port stays 8080. */
+    hostPort?: number;
+};
+export type GoldenStack = 'fastapi' | 'express';
+/** Normalize generated main.py uvicorn port to 8080 if present. */
+export declare function patchMainPyPort8080(content: string): string;
+/** Merge golden Docker/Makefile/README into an existing FastAPI file map. Caller must already set openapi.yaml from the deterministic exporter. */
+export declare function applyFastApiGoldenLayer(filesMap: Record<string, string>, options?: GoldenLayerOptions): void;
+/** Normalize Express entry to listen on 8080 by default. */
+export declare function patchExpressIndexPort8080(content: string): string;
+export declare function mergePackageJsonScripts(pkg: string): string;
+/** Golden layer for Express: expects openapi.yaml (and app files) from caller when available. */
+export declare function applyNodeExpressGoldenLayer(filesMap: Record<string, string>, options?: GoldenLayerOptions): void;
+//# sourceMappingURL=golden-bundle.d.ts.map

package/dist/golden-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"golden-bundle.d.ts","sourceRoot":"","sources":["../src/golden-bundle.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AA8EF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;AAiDhD,mEAAmE;AACnE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAI3D;AAED,mJAAmJ;AACnJ,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,GAAE,kBAAuB,GAC/B,IAAI,CAcN;AAED,4DAA4D;AAC5D,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAIjE;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED,iGAAiG;AACjG,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,GAAE,kBAAuB,GAC/B,IAAI,CAkBN"}

package/dist/golden-bundle.js

@@ -0,0 +1,166 @@
+/**
+ * Golden-path assets: IR-aligned OpenAPI is supplied by the caller (deterministic exporter).
+ * This module only applies Docker Compose, Dockerfile, Makefile, README section, and port patches.
+ *
+ * `hostPort` is the machine port (left side of docker publish). Container listens on 8080.
+ */
+function fastApiCompose(hostPort) {
+    return `version: '3.8'
+
+services:
+  api:
+    build: .
+    ports:
+      - "${hostPort}:8080"
+    volumes:
+      - .:/app
+    command: uvicorn app.main:app --host 0.0.0.0 --port 8080 --reload
+    environment:
+      - PYTHONUNBUFFERED=1
+`;
+}
+const GOLDEN_DOCKERFILE = `FROM python:3.11-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8080
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
+`;
+function nodeCompose(hostPort) {
+    return `version: '3.8'
+
+services:
+  api:
+    build: .
+    ports:
+      - "${hostPort}:8080"
+    volumes:
+      - .:/app
+    working_dir: /app
+    command: sh -c "npm install && node --watch app/index.js"
+    environment:
+      - PORT=8080
+      - NODE_ENV=development
+`;
+}
+const GOLDEN_NODE_DOCKERFILE = `FROM node:20-bookworm-slim
+WORKDIR /app
+COPY package.json ./
+RUN npm install
+COPY . .
+EXPOSE 8080
+ENV PORT=8080
+CMD ["node", "app/index.js"]
+`;
+const GOLDEN_MAKEFILE = `.PHONY: run dev install
+install:
+	pip install -r requirements.txt
+
+# One command to hide Docker details (golden demo)
+run:
+	docker compose up --build
+
+dev: run
+`;
+const GOLDEN_NODE_MAKEFILE = `.PHONY: run install
+install:
+	npm install
+
+run:
+	docker compose up --build
+
+dev: run
+`;
+const README_GOLDEN_MARKER = '<!-- ARCHRAD_GOLDEN_PATH -->';
+function appendGoldenReadmeSection(readme, stack = 'fastapi', hostPort = 8080) {
+    const hp = hostPort;
+    const validationBlurb = stack === 'express'
+        ? `Try validation on a signup-style POST (empty body should fail schema checks):
+
+\`\`\`bash
+curl -sS -X POST http://localhost:${hp}/signup -H "Content-Type: application/json" -d '{}'
+\`\`\`
+
+Expect **400 Bad Request** (or **422** if mapped) with **details** when routes use Ajv/OpenAPI-style validation — field errors should list missing/invalid keys.`
+        : `Try validation on a signup-style POST (empty body should fail FastAPI/Pydantic checks):
+
+\`\`\`bash
+curl -sS -X POST http://localhost:${hp}/signup -H "Content-Type: application/json" -d '{}'
+\`\`\`
+
+Expect **422 Unprocessable Entity** (default FastAPI) or **400** if routes use custom validation — field errors should list missing/invalid keys.`;
+    const section = `
+
+${README_GOLDEN_MARKER}
+## Golden path (local API, ~60s)
+
+\`\`\`bash
+make run
+# or: docker compose up --build
+\`\`\`
+
+Service listens on **http://localhost:${hp}** (maps host **${hp}** → container **8080**; hot reload: **FastAPI** = uvicorn --reload; **Express** = \`node --watch\` in compose).
+
+${validationBlurb}
+
+OpenAPI contract for this blueprint (IR-aligned) is in \`openapi.yaml\` at the project root.
+
+### Zero lock-in
+
+Generated services are **standard FastAPI or Express** stacks. They run with **Docker Compose** and **no ArchRad runtime**. If your org enabled optional policy SDK injection during export, remove \`sdk/archrad_*\` and related middleware—or set \`ARCHRAD_POLICY_SERVICE_URL\` empty—see upstream \`EXPORT_LOCK_IN_AUDIT.md\` in the main product repo.
+`;
+    if (readme.includes(README_GOLDEN_MARKER))
+        return readme;
+    return (readme || '').trimEnd() + section;
+}
+/** Normalize generated main.py uvicorn port to 8080 if present. */
+export function patchMainPyPort8080(content) {
+    return content
+        .replace(/uvicorn\.run\(\s*app\s*,\s*host=['"]0\.0\.0\.0['"]\s*,\s*port\s*=\s*8000\s*\)/g, "uvicorn.run(app, host='0.0.0.0', port=8080)")
+        .replace(/port\s*=\s*8000/g, 'port=8080');
+}
+/** Merge golden Docker/Makefile/README into an existing FastAPI file map. Caller must already set openapi.yaml from the deterministic exporter. */
+export function applyFastApiGoldenLayer(filesMap, options = {}) {
+    const hostPort = options.hostPort ?? 8080;
+    filesMap['docker-compose.yml'] = fastApiCompose(hostPort);
+    filesMap['Dockerfile'] = GOLDEN_DOCKERFILE;
+    filesMap['Makefile'] = GOLDEN_MAKEFILE;
+    if (filesMap['app/main.py']) {
+        filesMap['app/main.py'] = patchMainPyPort8080(filesMap['app/main.py']);
+    }
+    filesMap['README.md'] = appendGoldenReadmeSection(filesMap['README.md'] || '# Generated API\n', 'fastapi', hostPort);
+}
+/** Normalize Express entry to listen on 8080 by default. */
+export function patchExpressIndexPort8080(content) {
+    return content
+        .replace(/process\.env\.PORT\s*\|\|\s*3000/g, 'Number(process.env.PORT) || 8080')
+        .replace(/Number\(process\.env\.PORT\)\s*\|\|\s*3000/g, 'Number(process.env.PORT) || 8080');
+}
+export function mergePackageJsonScripts(pkg) {
+    try {
+        const j = JSON.parse(pkg);
+        j.scripts = j.scripts || {};
+        if (!j.scripts.start)
+            j.scripts.start = 'node app/index.js';
+        j.scripts.dev = 'node --watch app/index.js';
+        return JSON.stringify(j, null, 2);
+    }
+    catch {
+        return pkg;
+    }
+}
+/** Golden layer for Express: expects openapi.yaml (and app files) from caller when available. */
+export function applyNodeExpressGoldenLayer(filesMap, options = {}) {
+    const hostPort = options.hostPort ?? 8080;
+    filesMap['docker-compose.yml'] = nodeCompose(hostPort);
+    filesMap['Dockerfile'] = GOLDEN_NODE_DOCKERFILE;
+    filesMap['Makefile'] = GOLDEN_NODE_MAKEFILE;
+    if (filesMap['app/index.js']) {
+        filesMap['app/index.js'] = patchExpressIndexPort8080(filesMap['app/index.js']);
+    }
+    if (filesMap['package.json']) {
+        filesMap['package.json'] = mergePackageJsonScripts(filesMap['package.json']);
+    }
+    filesMap['README.md'] = appendGoldenReadmeSection(filesMap['README.md'] || '# Generated Express API\n', 'express', hostPort);
+}

package/dist/graphPredicates.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared graph predicates for structural validation and architecture lint (no imports from lint-graph / ir-structural).
+ */
+/** Node types treated as HTTP-like for path/method checks and lint (aligned structural + IR-LINT). */
+export declare function isHttpLikeType(t: string): boolean;
+/** Datastore-like (unchanged semantics; kept adjacent for docs). */
+export declare function isDbLikeType(t: string): boolean;
+/** Queue / topic / stream node types → treat incoming edges as async boundaries when edge metadata is absent. */
+export declare function isQueueLikeNodeType(t: string): boolean;
+//# sourceMappingURL=graphPredicates.d.ts.map

package/dist/graphPredicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphPredicates.d.ts","sourceRoot":"","sources":["../src/graphPredicates.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,sGAAsG;AACtG,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAQjD;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAM/C;AAED,iHAAiH;AACjH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAStD"}

package/dist/graphPredicates.js

@@ -0,0 +1,33 @@
+/**
+ * Shared graph predicates for structural validation and architecture lint (no imports from lint-graph / ir-structural).
+ */
+/** Node types treated as HTTP-like for path/method checks and lint (aligned structural + IR-LINT). */
+export function isHttpLikeType(t) {
+    const s = String(t ?? '')
+        .trim()
+        .toLowerCase();
+    if (!s)
+        return false;
+    if (s === 'http' || s === 'https' || s === 'rest' || s === 'api')
+        return true;
+    if (s === 'gateway' || s === 'bff' || s === 'graphql' || s === 'grpc')
+        return true;
+    return /\b(api|gateway|bff|graphql|grpc)\b/.test(s);
+}
+/** Datastore-like (unchanged semantics; kept adjacent for docs). */
+export function isDbLikeType(t) {
+    if (!t)
+        return false;
+    return (/\b(db|database|datastore)\b/.test(t) ||
+        /postgres|mongodb|mysql|sqlite|redis|cassandra|dynamo|sql|nosql|warehouse|s3/.test(t));
+}
+/** Queue / topic / stream node types → treat incoming edges as async boundaries when edge metadata is absent. */
+export function isQueueLikeNodeType(t) {
+    const s = String(t ?? '')
+        .trim()
+        .toLowerCase();
+    if (!s)
+        return false;
+    return (/\b(queue|topic|stream|pubsub|event|bus)\b/.test(s) ||
+        /kafka|sns|sqs|amqp|mqtt|nats|rabbitmq|pulsar/.test(s));
+}

package/dist/hostPort.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Host-side port for docker-compose publish (container keeps 8080).
+ */
+export declare const DEFAULT_GOLDEN_HOST_PORT = 8080;
+/** Valid TCP port for the host mapping; falls back to DEFAULT_GOLDEN_HOST_PORT. */
+export declare function normalizeGoldenHostPort(value: unknown): number;
+/**
+ * True if nothing is listening on 127.0.0.1:port (we can bind briefly).
+ * On permission errors, returns true so export is not blocked.
+ */
+export declare function isLocalHostPortFree(port: number): Promise<boolean>;
+//# sourceMappingURL=hostPort.d.ts.map

package/dist/hostPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostPort.d.ts","sourceRoot":"","sources":["../src/hostPort.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,mFAAmF;AACnF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAM9D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBlE"}

package/dist/hostPort.js

@@ -0,0 +1,39 @@
+/**
+ * Host-side port for docker-compose publish (container keeps 8080).
+ */
+import { createServer } from 'node:net';
+export const DEFAULT_GOLDEN_HOST_PORT = 8080;
+/** Valid TCP port for the host mapping; falls back to DEFAULT_GOLDEN_HOST_PORT. */
+export function normalizeGoldenHostPort(value) {
+    const n = typeof value === 'string' ? parseInt(value, 10) : Number(value);
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+        return DEFAULT_GOLDEN_HOST_PORT;
+    }
+    return n;
+}
+/**
+ * True if nothing is listening on 127.0.0.1:port (we can bind briefly).
+ * On permission errors, returns true so export is not blocked.
+ */
+export function isLocalHostPortFree(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.unref();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+                return;
+            }
+            resolve(true);
+        });
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        try {
+            server.listen(port, '127.0.0.1');
+        }
+        catch {
+            resolve(true);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @archrad/deterministic — IR structural validation, FastAPI/Express generators, OpenAPI **document-shape**
+ * checks, golden Docker/Makefile (no LLM). Semantic architecture / compliance lives in ArchRad Cloud.
+ */
+export { findOpenApiInBundle, parseOpenApiString, validateOpenApiStructural, serializeOpenApiDoc, validateOpenApiInBundleStructural, } from './openapi-structural.js';
+export { applyFastApiGoldenLayer, applyNodeExpressGoldenLayer, patchMainPyPort8080, patchExpressIndexPort8080, mergePackageJsonScripts, type GoldenStack, type GoldenLayerOptions, } from './golden-bundle.js';
+export { DEFAULT_GOLDEN_HOST_PORT, normalizeGoldenHostPort, isLocalHostPortFree, } from './hostPort.js';
+export * from './edgeConfigCodeGenerator.js';
+export { default as generatePythonFastAPIFiles } from './pythonFastAPI.js';
+export { default as generateNodeExpressFiles } from './nodeExpress.js';
+export { runDeterministicExport, type DeterministicExportResult } from './exportPipeline.js';
+export { diffExpectedExportAgainstFiles, diffExpectedExportAgainstDirectory, readDirectoryAsExportMap, runValidateDrift, runDriftCheckAgainstFiles, normalizeExportFileContent, type DriftFinding, type DriftCode, type ValidateDriftResult, type DriftCheckFilesResult, } from './validate-drift.js';
+export { normalizeIrGraph, validateIrStructural, hasIrStructuralErrors, type IrStructuralFinding, type IrStructuralSeverity, type IrFindingLayer, } from './ir-structural.js';
+export { materializeNormalizedGraph, normalizeNodeSlot, normalizeEdgeSlot, type NormalizedGraph, type NormalizedNode, type NormalizedEdge, type MaterializeResult, } from './ir-normalize.js';
+export { validateIrLint } from './ir-lint.js';
+export { runArchitectureLinting, LINT_RULE_REGISTRY } from './lint-rules.js';
+export { buildParsedLintGraph, isParsedLintGraph, type ParsedLintGraph, type BuildParsedLintGraphResult, } from './lint-graph.js';
+export { isHttpLikeType, isDbLikeType, isQueueLikeNodeType } from './graphPredicates.js';
+export { sortFindings, shouldFailFromFindings, type ValidationExitPolicy } from './cli-findings.js';
+export { parseYamlToCanonicalIr, canonicalIrToJsonString, YamlGraphParseError, } from './yamlToIr.js';
+export { openApiDocumentToHttpNodes, openApiDocumentToCanonicalIr, openApiStringToCanonicalIr, openApiUnknownToCanonicalIr, OpenApiIngestError, type OpenApiHttpNode, } from './openapi-to-ir.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,iCAAiC,GAClC,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,KAAK,WAAW,EAChB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AAEvB,cAAc,8BAA8B,CAAC;AAE7C,OAAO,EAAE,OAAO,IAAI,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAEvE,OAAO,EAAE,sBAAsB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAE7F,OAAO,EACL,8BAA8B,EAC9B,kCAAkC,EAClC,wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EACzB,0BAA0B,EAC1B,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,cAAc,GACpB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,KAAK,eAAe,EACpB,KAAK,0BAA0B,GAChC,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEpG,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,EAC3B,kBAAkB,EAClB,KAAK,eAAe,GACrB,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * @archrad/deterministic — IR structural validation, FastAPI/Express generators, OpenAPI **document-shape**
+ * checks, golden Docker/Makefile (no LLM). Semantic architecture / compliance lives in ArchRad Cloud.
+ */
+export { findOpenApiInBundle, parseOpenApiString, validateOpenApiStructural, serializeOpenApiDoc, validateOpenApiInBundleStructural, } from './openapi-structural.js';
+export { applyFastApiGoldenLayer, applyNodeExpressGoldenLayer, patchMainPyPort8080, patchExpressIndexPort8080, mergePackageJsonScripts, } from './golden-bundle.js';
+export { DEFAULT_GOLDEN_HOST_PORT, normalizeGoldenHostPort, isLocalHostPortFree, } from './hostPort.js';
+export * from './edgeConfigCodeGenerator.js';
+export { default as generatePythonFastAPIFiles } from './pythonFastAPI.js';
+export { default as generateNodeExpressFiles } from './nodeExpress.js';
+export { runDeterministicExport } from './exportPipeline.js';
+export { diffExpectedExportAgainstFiles, diffExpectedExportAgainstDirectory, readDirectoryAsExportMap, runValidateDrift, runDriftCheckAgainstFiles, normalizeExportFileContent, } from './validate-drift.js';
+export { normalizeIrGraph, validateIrStructural, hasIrStructuralErrors, } from './ir-structural.js';
+export { materializeNormalizedGraph, normalizeNodeSlot, normalizeEdgeSlot, } from './ir-normalize.js';
+export { validateIrLint } from './ir-lint.js';
+export { runArchitectureLinting, LINT_RULE_REGISTRY } from './lint-rules.js';
+export { buildParsedLintGraph, isParsedLintGraph, } from './lint-graph.js';
+export { isHttpLikeType, isDbLikeType, isQueueLikeNodeType } from './graphPredicates.js';
+export { sortFindings, shouldFailFromFindings } from './cli-findings.js';
+export { parseYamlToCanonicalIr, canonicalIrToJsonString, YamlGraphParseError, } from './yamlToIr.js';
+export { openApiDocumentToHttpNodes, openApiDocumentToCanonicalIr, openApiStringToCanonicalIr, openApiUnknownToCanonicalIr, OpenApiIngestError, } from './openapi-to-ir.js';

package/dist/ir-lint.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Architecture lint (IR-LINT-*): thin entry — parses graph then runs visitor registry in `lint-rules.ts`.
+ */
+import type { IrStructuralFinding } from './ir-structural.js';
+/**
+ * Run architecture lint (IR-LINT-*). If the IR cannot be parsed (invalid root, empty graph, etc.),
+ * returns the same **structural** findings as `normalizeIrGraph` / `validateIrStructural` would surface
+ * for that shape — callers that only invoke `validateIrLint` still see blockers instead of a silent `[]`.
+ */
+export declare function validateIrLint(ir: unknown): IrStructuralFinding[];
+//# sourceMappingURL=ir-lint.d.ts.map

package/dist/ir-lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-lint.d.ts","sourceRoot":"","sources":["../src/ir-lint.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,OAAO,GAAG,mBAAmB,EAAE,CAIjE"}

package/dist/ir-lint.js

@@ -0,0 +1,16 @@
+/**
+ * Architecture lint (IR-LINT-*): thin entry — parses graph then runs visitor registry in `lint-rules.ts`.
+ */
+import { buildParsedLintGraph, isParsedLintGraph } from './lint-graph.js';
+import { runArchitectureLinting } from './lint-rules.js';
+/**
+ * Run architecture lint (IR-LINT-*). If the IR cannot be parsed (invalid root, empty graph, etc.),
+ * returns the same **structural** findings as `normalizeIrGraph` / `validateIrStructural` would surface
+ * for that shape — callers that only invoke `validateIrLint` still see blockers instead of a silent `[]`.
+ */
+export function validateIrLint(ir) {
+    const built = buildParsedLintGraph(ir);
+    if (!isParsedLintGraph(built))
+        return built.findings;
+    return runArchitectureLinting(built);
+}

package/dist/ir-normalize.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Parser boundary: external IR → internal normalized graph shape.
+ * Generators still receive the original IR object; use normalized form for validation/lint only.
+ */
+export type NormalizedNode = {
+    id: string;
+    /** Lowercased from `type` or `kind` */
+    type: string;
+    name: string;
+    config: Record<string, unknown>;
+    schema: Record<string, unknown>;
+};
+export type NormalizedEdge = {
+    id: string;
+    from: string;
+    to: string;
+    config: Record<string, unknown>;
+    /** Preserved for lint (e.g. async / protocol); generators still use raw IR. */
+    metadata: Record<string, unknown>;
+};
+export type NormalizedGraph = {
+    metadata: Record<string, unknown>;
+    nodes: NormalizedNode[];
+    edges: NormalizedEdge[];
+};
+/**
+ * Coerce one node slot to the internal shape (invalid input → empty fields; structural rules flag issues).
+ */
+export declare function normalizeNodeSlot(raw: unknown): NormalizedNode;
+/**
+ * Coerce one edge slot to internal `from` / `to` (accepts legacy `source` / `target`).
+ */
+export declare function normalizeEdgeSlot(raw: unknown): NormalizedEdge;
+export type MaterializeResult = {
+    normalized: NormalizedGraph;
+    /** True when `edges` was present but not an array (treated as []). */
+    edgesInputWasMalformed: boolean;
+};
+/**
+ * Build internal normalized graph from an already-unwrapped `graph` object
+ * (`normalizeIrGraph` must have succeeded). Does not validate semantics.
+ *
+ * **Contract:** `normalized.edges[i]` corresponds 1:1 to `graph.edges[i]` when `edges` is an array;
+ * structural validation and lint assume this index alignment. If edges are filtered or merged later,
+ * keep positions or re-run materialization from the same raw array.
+ */
+export declare function materializeNormalizedGraph(graph: Record<string, unknown>): MaterializeResult;
+//# sourceMappingURL=ir-normalize.d.ts.map

package/dist/ir-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-normalize.d.ts","sourceRoot":"","sources":["../src/ir-normalize.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,KAAK,EAAE,cAAc,EAAE,CAAC;IACxB,KAAK,EAAE,cAAc,EAAE,CAAC;CACzB,CAAC;AAOF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAiB9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,cAAc,CAuB9D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,eAAe,CAAC;IAC5B,sEAAsE;IACtE,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,iBAAiB,CAkB5F"}

package/dist/ir-normalize.js

@@ -0,0 +1,81 @@
+/**
+ * Parser boundary: external IR → internal normalized graph shape.
+ * Generators still receive the original IR object; use normalized form for validation/lint only.
+ */
+function emptyRecord(obj) {
+    if (obj && typeof obj === 'object' && !Array.isArray(obj))
+        return obj;
+    return {};
+}
+/**
+ * Coerce one node slot to the internal shape (invalid input → empty fields; structural rules flag issues).
+ */
+export function normalizeNodeSlot(raw) {
+    if (raw == null || typeof raw !== 'object') {
+        return { id: '', type: '', name: '', config: {}, schema: {} };
+    }
+    const r = raw;
+    const id = String(r.id ?? '').trim();
+    const type = String(r.type ?? r.kind ?? '')
+        .trim()
+        .toLowerCase();
+    const name = String(r.name ?? '').trim();
+    return {
+        id,
+        type,
+        name,
+        config: emptyRecord(r.config),
+        schema: emptyRecord(r.schema),
+    };
+}
+/**
+ * Coerce one edge slot to internal `from` / `to` (accepts legacy `source` / `target`).
+ */
+export function normalizeEdgeSlot(raw) {
+    if (raw == null || typeof raw !== 'object') {
+        return { id: '', from: '', to: '', config: {}, metadata: {} };
+    }
+    const r = raw;
+    const from = String(r.from ?? r.source ?? '').trim();
+    const to = String(r.to ?? r.target ?? '').trim();
+    const id = String(r.id ?? '').trim();
+    const metadata = emptyRecord(r.metadata);
+    const topKind = r.kind;
+    if (topKind !== undefined && topKind !== null && String(topKind).trim() !== '') {
+        const k = String(topKind).trim();
+        if (metadata.kind == null || String(metadata.kind).trim() === '') {
+            metadata.kind = k;
+        }
+    }
+    return {
+        id,
+        from,
+        to,
+        config: emptyRecord(r.config),
+        metadata,
+    };
+}
+/**
+ * Build internal normalized graph from an already-unwrapped `graph` object
+ * (`normalizeIrGraph` must have succeeded). Does not validate semantics.
+ *
+ * **Contract:** `normalized.edges[i]` corresponds 1:1 to `graph.edges[i]` when `edges` is an array;
+ * structural validation and lint assume this index alignment. If edges are filtered or merged later,
+ * keep positions or re-run materialization from the same raw array.
+ */
+export function materializeNormalizedGraph(graph) {
+    const metadata = emptyRecord(graph.metadata);
+    const nodesRaw = Array.isArray(graph.nodes) ? graph.nodes : [];
+    const nodes = nodesRaw.map((n) => normalizeNodeSlot(n));
+    const edgesMalformed = graph.edges !== undefined && !Array.isArray(graph.edges);
+    const edgesRaw = Array.isArray(graph.edges) ? graph.edges : [];
+    const edges = edgesRaw.map((e) => normalizeEdgeSlot(e));
+    return {
+        normalized: {
+            metadata,
+            nodes,
+            edges,
+        },
+        edgesInputWasMalformed: edgesMalformed,
+    };
+}

package/dist/ir-structural.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Deterministic structural validation of blueprint IR (graph JSON).
+ * OSS boundary: shape, references, cycles — not security/compliance semantics (ArchRad Cloud).
+ */
+export type IrStructuralSeverity = 'error' | 'warning' | 'info';
+/** IR shape/refs (IR-STRUCT-*) vs deterministic architecture heuristics (IR-LINT-*) */
+export type IrFindingLayer = 'structural' | 'lint';
+export type IrStructuralFinding = {
+    code: string;
+    severity: IrStructuralSeverity;
+    message: string;
+    /** Primary node id when relevant */
+    nodeId?: string;
+    /** Index in graph.edges[] */
+    edgeIndex?: number;
+    /** Short actionable hint (structural); also used as primary “Fix:” line in CLI when no suggestion */
+    fixHint?: string;
+    /** Set for IR-LINT-* findings */
+    layer?: IrFindingLayer;
+    /** Longer lint guidance (CLI “Suggestion:”) */
+    suggestion?: string;
+    /** Risk/context line (CLI “Impact:”) */
+    impact?: string;
+};
+/**
+ * Normalize product / CLI shapes to a single graph object.
+ * Accepts `{ graph: { nodes, edges } }` or a bare `{ nodes, edges }`.
+ */
+export declare function normalizeIrGraph(ir: unknown): {
+    graph: Record<string, unknown>;
+} | {
+    findings: IrStructuralFinding[];
+};
+/**
+ * Structural validation only: well-formed graph, edge references, directed cycles, HTTP node config.
+ * Same input → same findings (deterministic).
+ */
+export declare function validateIrStructural(ir: unknown): IrStructuralFinding[];
+export declare function hasIrStructuralErrors(findings: IrStructuralFinding[]): boolean;
+//# sourceMappingURL=ir-structural.d.ts.map

package/dist/ir-structural.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-structural.d.ts","sourceRoot":"","sources":["../src/ir-structural.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAEhE,uFAAuF;AACvF,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,MAAM,CAAC;AAEnD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6BAA6B;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qGAAqG;IACrG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAIF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,GAAG;IAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,CA8BtH;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,GAAG,mBAAmB,EAAE,CAgOvE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAE9E"}