@nekostack/schema 1.0.0

package/dist/src/registry/handlers/list.js

@@ -0,0 +1,84 @@
+/**
+ * `listHandler({ registry })` — enumerate every `RegistryEntry` in a
+ * `Registry`, in a stable order, as a `Result<{ entries }>`.
+ *
+ * The simplest of the four v0.7 handlers; landing this commit first
+ * pins the handler shape and the `Result<T>` discriminated-union
+ * contract before `diff` / `check` / `generate` add per-handler
+ * complexity (Master plan sequencing step 8).
+ *
+ * **Pure.** No filesystem, no `import()`, no `process.*`, no
+ * `console.*`. Takes an already-built `Registry` (Step 6's
+ * `buildRegistry` output) and returns a `Result` over a flat array.
+ * Master plan Decision #1 boundary.
+ *
+ * Ordering (deterministic; documented in tests):
+ *
+ * 1. **Across `schemaId`**: alphabetical ascending.
+ * 2. **Within one `schemaId`**: versioned entries first, ascending
+ *    by numeric major.minor.patch semver (so `1.0.0` < `2.0.0` <
+ *    `10.0.0`, never lexicographic `10.0.0` < `2.0.0`). Unversioned
+ *    entries (the empty-string inner key from Step 6) come **last**.
+ *
+ * Rationale for "unversioned last":
+ * - Putting unversioned first would sort empty-string `""` before
+ *   any semver — visually surprising in CLI output.
+ * - Unversioned schemas are the v0.7 fallback for `.id()`-without-
+ *   `.version()`. Most workspaces won't have any. Sorting them at
+ *   the tail makes them visually distinct from the canonical
+ *   versioned list.
+ *
+ * Empty registry: returns `{ success: true, data: { entries: [] } }`.
+ * Never returns failure — list is read-only, has no failure mode.
+ */
+export function listHandler(opts) {
+    const entries = [];
+    const schemaIds = [...opts.registry.keys()].sort();
+    for (const schemaId of schemaIds) {
+        const inner = opts.registry.get(schemaId);
+        if (inner === undefined)
+            continue; // unreachable given iteration source
+        const versionKeys = [];
+        let hasUnversioned = false;
+        for (const key of inner.keys()) {
+            if (key === "")
+                hasUnversioned = true;
+            else
+                versionKeys.push(key);
+        }
+        versionKeys.sort(compareSemver);
+        for (const v of versionKeys) {
+            const entry = inner.get(v);
+            if (entry !== undefined)
+                entries.push(entry);
+        }
+        if (hasUnversioned) {
+            const entry = inner.get("");
+            if (entry !== undefined)
+                entries.push(entry);
+        }
+    }
+    return { success: true, data: { entries } };
+}
+/**
+ * Numeric semver compare on `major.minor.patch`. Falls back to
+ * `localeCompare` for non-matching inputs so non-standard version
+ * strings (e.g., `"1.0.0-rc.1"`) sort deterministically without
+ * throwing. Duplicates `build-registry.ts`'s private helper; the
+ * two consumers are small enough that DRY-vs-coupling is a wash
+ * for v0.7. If a third consumer emerges, factor into a registry-
+ * internal `semver.ts`.
+ */
+function compareSemver(a, b) {
+    const ax = a.match(/(\d+)\.(\d+)\.(\d+)/);
+    const bx = b.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!ax || !bx)
+        return a.localeCompare(b);
+    for (let i = 1; i <= 3; i++) {
+        const d = Number(ax[i]) - Number(bx[i]);
+        if (d !== 0)
+            return d;
+    }
+    return a.localeCompare(b);
+}
+//# sourceMappingURL=list.js.map

package/dist/src/registry/handlers/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../../../src/registry/handlers/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAQH,MAAM,UAAU,WAAW,CAAC,IAAc;IACxC,MAAM,OAAO,GAAoB,EAAE,CAAC;IACpC,MAAM,SAAS,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;IACnD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1C,IAAI,KAAK,KAAK,SAAS;YAAE,SAAS,CAAC,qCAAqC;QAExE,MAAM,WAAW,GAAa,EAAE,CAAC;QACjC,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;YAC/B,IAAI,GAAG,KAAK,EAAE;gBAAE,cAAc,GAAG,IAAI,CAAC;;gBACjC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC;QACD,WAAW,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAEhC,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;YAC5B,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAC3B,IAAI,KAAK,KAAK,SAAS;gBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,cAAc,EAAE,CAAC;YACnB,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC5B,IAAI,KAAK,KAAK,SAAS;gBAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,aAAa,CAAC,CAAS,EAAE,CAAS;IACzC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC1C,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC;IAC1C,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE;QAAE,OAAO,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AAC5B,CAAC"}

package/dist/src/registry/parse-provenance.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Provenance parser for generated artifacts (Master plan Step 5).
+ *
+ * Reads the provenance metadata back out of an emitted artifact so
+ * `checkHandler` (Step 10) can compare it against the current schema
+ * source. Two carrier shapes are supported, mirroring the Step 4
+ * emitter side:
+ *
+ * - **JSDoc header** (TS / Zod) — `/** ... * /` block at the top of
+ *   the file. Each provenance field lives on its own `* <name>: <value>`
+ *   line. The `@generated` line, the `// anonymous schema` line, the
+ *   blank `*` line, and the `DO NOT EDIT MANUALLY` line are skipped.
+ *
+ * - **`x-nekostack` block** (JSON Schema / OpenAPI) — a single object
+ *   under the `x-nekostack` key at the document root. The provenance
+ *   fields are own properties of that object.
+ *
+ * The function is **pure**: no `fs.*`, no `import()`, no path argument.
+ * The CLI reads the artifact text from disk and hands it in; this
+ * module parses and returns. Master plan Decision #1 boundary applies.
+ *
+ * **Backward compatibility (Master plan Decision #8):** v0.6-era
+ * artifacts have no `sourceHash` line / field. They are parsed
+ * successfully; `sourceHash` is `undefined` on the result, never
+ * `null`. The freshness verdict in `checkHandler` treats absent
+ * `sourceHash` as "unknown" — NOT as an integrity error.
+ *
+ * **Malformed / missing provenance** surfaces as `Result<...>` failure
+ * with one `Issue` of code `"integrity_error"`. `metadata.reason`
+ * records the specific sub-mode (unknown_format, missing_field,
+ * malformed_hash, json_parse_error, etc.) so consumers downstream can
+ * triage without parsing `message`. The CLI's `checkHandler` step
+ * (Step 10) maps an integrity_error result onto the
+ * `FreshnessVerdict.status = "integrity_error"` shape with exit code 4.
+ */
+import type { Result } from "../errors/issue.js";
+/**
+ * Parsed provenance fields. Matches the union of what TS/Zod JSDoc
+ * headers and JSON-side `x-nekostack` blocks carry.
+ *
+ * `schemaId` / `schemaVersion` are `null` for anonymous / unversioned
+ * schemas (the emitter writes the literal string `"null"` in JSDoc and
+ * the JSON value `null` in `x-nekostack`; both decode to JS `null`
+ * here). `sourceHash` is `undefined` when absent — never `null`.
+ */
+export interface ParsedProvenance {
+    readonly generator: string;
+    readonly generatorVersion: string;
+    readonly schemaId: string | null;
+    readonly schemaVersion: string | null;
+    readonly irHash: `sha256:${string}`;
+    readonly sourceHash: `sha256:${string}` | undefined;
+}
+/**
+ * Parse the provenance block out of an artifact's text content.
+ *
+ * Auto-detects the carrier by leading non-whitespace character:
+ *   `/`  → JSDoc header (TS / Zod source artifact)
+ *   `{`  → JSON document (JSON Schema / OpenAPI artifact)
+ *   else → integrity_error / unknown_format
+ */
+export declare function parseProvenanceFromText(content: string): Result<ParsedProvenance>;
+//# sourceMappingURL=parse-provenance.d.ts.map

package/dist/src/registry/parse-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-provenance.d.ts","sourceRoot":"","sources":["../../../src/registry/parse-provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAS,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAOxD;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,UAAU,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,UAAU,EAAE,UAAU,MAAM,EAAE,GAAG,SAAS,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,gBAAgB,CAAC,CAY1B"}

package/dist/src/registry/parse-provenance.js

@@ -0,0 +1,182 @@
+/**
+ * Provenance parser for generated artifacts (Master plan Step 5).
+ *
+ * Reads the provenance metadata back out of an emitted artifact so
+ * `checkHandler` (Step 10) can compare it against the current schema
+ * source. Two carrier shapes are supported, mirroring the Step 4
+ * emitter side:
+ *
+ * - **JSDoc header** (TS / Zod) — `/** ... * /` block at the top of
+ *   the file. Each provenance field lives on its own `* <name>: <value>`
+ *   line. The `@generated` line, the `// anonymous schema` line, the
+ *   blank `*` line, and the `DO NOT EDIT MANUALLY` line are skipped.
+ *
+ * - **`x-nekostack` block** (JSON Schema / OpenAPI) — a single object
+ *   under the `x-nekostack` key at the document root. The provenance
+ *   fields are own properties of that object.
+ *
+ * The function is **pure**: no `fs.*`, no `import()`, no path argument.
+ * The CLI reads the artifact text from disk and hands it in; this
+ * module parses and returns. Master plan Decision #1 boundary applies.
+ *
+ * **Backward compatibility (Master plan Decision #8):** v0.6-era
+ * artifacts have no `sourceHash` line / field. They are parsed
+ * successfully; `sourceHash` is `undefined` on the result, never
+ * `null`. The freshness verdict in `checkHandler` treats absent
+ * `sourceHash` as "unknown" — NOT as an integrity error.
+ *
+ * **Malformed / missing provenance** surfaces as `Result<...>` failure
+ * with one `Issue` of code `"integrity_error"`. `metadata.reason`
+ * records the specific sub-mode (unknown_format, missing_field,
+ * malformed_hash, json_parse_error, etc.) so consumers downstream can
+ * triage without parsing `message`. The CLI's `checkHandler` step
+ * (Step 10) maps an integrity_error result onto the
+ * `FreshnessVerdict.status = "integrity_error"` shape with exit code 4.
+ */
+import { JSON_SCHEMA_EXTENSIONS } from "../generators/json-schema-meta.js";
+const PROVENANCE_KEY = JSON_SCHEMA_EXTENSIONS.provenance; // "x-nekostack"
+const SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+/**
+ * Parse the provenance block out of an artifact's text content.
+ *
+ * Auto-detects the carrier by leading non-whitespace character:
+ *   `/`  → JSDoc header (TS / Zod source artifact)
+ *   `{`  → JSON document (JSON Schema / OpenAPI artifact)
+ *   else → integrity_error / unknown_format
+ */
+export function parseProvenanceFromText(content) {
+    const trimmed = content.trimStart();
+    if (trimmed.startsWith("/**")) {
+        return parseJsdocHeader(content);
+    }
+    if (trimmed.startsWith("{")) {
+        return parseJsonProvenance(content);
+    }
+    return fail("unknown_format", "Artifact does not start with `/**` (TS/Zod) or `{` (JSON Schema / OpenAPI).");
+}
+// =============================================================================
+// JSDoc header parsing (TS / Zod)
+// =============================================================================
+const JSDOC_BLOCK = /\/\*\*([\s\S]*?)\*\//;
+const JSDOC_FIELD = /^\s*\*\s+(\w+):\s*(.+?)\s*$/;
+function parseJsdocHeader(content) {
+    const block = JSDOC_BLOCK.exec(content);
+    if (!block) {
+        return fail("missing_provenance", "No `/** ... */` JSDoc header found at the top of the artifact.");
+    }
+    const fields = new Map();
+    for (const line of block[1].split(/\r?\n/)) {
+        const m = JSDOC_FIELD.exec(line);
+        if (!m)
+            continue;
+        fields.set(m[1], m[2]);
+    }
+    return assembleProvenance(fields);
+}
+// =============================================================================
+// JSON `x-nekostack` parsing (JSON Schema / OpenAPI)
+// =============================================================================
+function parseJsonProvenance(content) {
+    let doc;
+    try {
+        doc = JSON.parse(content);
+    }
+    catch (e) {
+        return fail("json_parse_error", `Artifact failed JSON.parse: ${e.message}`);
+    }
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        return fail("missing_provenance", "Parsed JSON is not an object; cannot read `x-nekostack` provenance.");
+    }
+    const root = doc;
+    const provenance = root[PROVENANCE_KEY];
+    if (provenance === null ||
+        typeof provenance !== "object" ||
+        Array.isArray(provenance)) {
+        return fail("missing_provenance", `Artifact has no \`${PROVENANCE_KEY}\` provenance object at the document root.`);
+    }
+    const block = provenance;
+    const fields = new Map();
+    for (const key of [
+        "generator",
+        "generatorVersion",
+        "schemaId",
+        "schemaVersion",
+        "irHash",
+        "sourceHash",
+    ]) {
+        const v = block[key];
+        if (v === undefined)
+            continue;
+        // `schemaId` / `schemaVersion` may be JSON `null` for anonymous /
+        // unversioned schemas. Normalize to the literal string "null" so
+        // the assembler can apply the same rule as the JSDoc path.
+        if (v === null) {
+            fields.set(key, "null");
+            continue;
+        }
+        if (typeof v !== "string") {
+            return fail("malformed_field", `Field \`${key}\` in \`${PROVENANCE_KEY}\` must be a string or null; got ${typeof v}.`);
+        }
+        fields.set(key, v);
+    }
+    return assembleProvenance(fields);
+}
+// =============================================================================
+// Shared field assembly + validation
+// =============================================================================
+function assembleProvenance(fields) {
+    const generator = fields.get("generator");
+    const generatorVersion = fields.get("generatorVersion");
+    const schemaIdRaw = fields.get("schemaId");
+    const schemaVersionRaw = fields.get("schemaVersion");
+    const irHash = fields.get("irHash");
+    const sourceHashRaw = fields.get("sourceHash");
+    if (generator === undefined) {
+        return fail("missing_field", "Provenance is missing `generator`.");
+    }
+    if (generatorVersion === undefined) {
+        return fail("missing_field", "Provenance is missing `generatorVersion`.");
+    }
+    if (schemaIdRaw === undefined) {
+        return fail("missing_field", "Provenance is missing `schemaId`.");
+    }
+    if (schemaVersionRaw === undefined) {
+        return fail("missing_field", "Provenance is missing `schemaVersion`.");
+    }
+    if (irHash === undefined) {
+        return fail("missing_field", "Provenance is missing `irHash`.");
+    }
+    if (!SHA256_PATTERN.test(irHash)) {
+        return fail("malformed_hash", `Provenance \`irHash\` must match \`sha256:<64 hex>\`; got "${irHash}".`);
+    }
+    if (sourceHashRaw !== undefined && !SHA256_PATTERN.test(sourceHashRaw)) {
+        return fail("malformed_hash", `Provenance \`sourceHash\` must match \`sha256:<64 hex>\` when present; got "${sourceHashRaw}".`);
+    }
+    return {
+        success: true,
+        data: {
+            generator,
+            generatorVersion,
+            schemaId: schemaIdRaw === "null" ? null : schemaIdRaw,
+            schemaVersion: schemaVersionRaw === "null" ? null : schemaVersionRaw,
+            irHash: irHash,
+            sourceHash: sourceHashRaw === undefined
+                ? undefined
+                : sourceHashRaw,
+        },
+    };
+}
+// =============================================================================
+// Failure helper
+// =============================================================================
+function fail(reason, message) {
+    const issue = {
+        code: "integrity_error",
+        path: [],
+        message,
+        severity: "error",
+        metadata: { reason },
+    };
+    return { success: false, issues: [issue] };
+}
+//# sourceMappingURL=parse-provenance.js.map

package/dist/src/registry/parse-provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-provenance.js","sourceRoot":"","sources":["../../../src/registry/parse-provenance.ts"],"names":[],"mappings":"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"}

package/dist/src/registry/source-hash.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Compute the `sourceHash` of a schema source file from its raw text
+ * content. Master plan Decision #7: `sourceHash` is sha256 of the
+ * source file's raw UTF-8 bytes — not the AST, not a canonicalized
+ * form. The point is to detect *any* source-text edit; canonicalizing
+ * would mask intentional reformatting and rebuild churn.
+ *
+ * **Pure.** No filesystem access; the CLI is responsible for reading
+ * the file and passing the text in. This is the load-bearing
+ * schema/cli boundary from Master plan Decision #1.
+ *
+ * Output format: `sha256:<64 lowercase hex chars>`. The prefixed
+ * template-literal type is the canonical form everywhere
+ * `sourceHash` appears in the v0.7 surface (`RegistryEntry`,
+ * `GeneratedArtifact`, `ProvenanceOptions`, etc.) so consumers can't
+ * accidentally confuse raw hex with the prefixed form at the type
+ * level.
+ *
+ * Distinct from `irHash` (`../ir/hash.ts`):
+ * - `irHash`         — semantic identity (canonicalized IR)
+ * - `sourceHashFromText` — source-text identity (raw bytes)
+ *
+ * The two-hash discipline in Master plan §"Freshness verdict" is
+ * what `checkHandler` uses to classify each artifact as
+ * clean / cosmetic_drift / stale / integrity_error.
+ */
+export declare function sourceHashFromText(text: string): `sha256:${string}`;
+//# sourceMappingURL=source-hash.d.ts.map

package/dist/src/registry/source-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-hash.d.ts","sourceRoot":"","sources":["../../../src/registry/source-hash.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,MAAM,EAAE,CAGnE"}

package/dist/src/registry/source-hash.js

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+/**
+ * Compute the `sourceHash` of a schema source file from its raw text
+ * content. Master plan Decision #7: `sourceHash` is sha256 of the
+ * source file's raw UTF-8 bytes — not the AST, not a canonicalized
+ * form. The point is to detect *any* source-text edit; canonicalizing
+ * would mask intentional reformatting and rebuild churn.
+ *
+ * **Pure.** No filesystem access; the CLI is responsible for reading
+ * the file and passing the text in. This is the load-bearing
+ * schema/cli boundary from Master plan Decision #1.
+ *
+ * Output format: `sha256:<64 lowercase hex chars>`. The prefixed
+ * template-literal type is the canonical form everywhere
+ * `sourceHash` appears in the v0.7 surface (`RegistryEntry`,
+ * `GeneratedArtifact`, `ProvenanceOptions`, etc.) so consumers can't
+ * accidentally confuse raw hex with the prefixed form at the type
+ * level.
+ *
+ * Distinct from `irHash` (`../ir/hash.ts`):
+ * - `irHash`         — semantic identity (canonicalized IR)
+ * - `sourceHashFromText` — source-text identity (raw bytes)
+ *
+ * The two-hash discipline in Master plan §"Freshness verdict" is
+ * what `checkHandler` uses to classify each artifact as
+ * clean / cosmetic_drift / stale / integrity_error.
+ */
+export function sourceHashFromText(text) {
+    const digest = createHash("sha256").update(text, "utf8").digest("hex");
+    return `sha256:${digest}`;
+}
+//# sourceMappingURL=source-hash.js.map

package/dist/src/registry/source-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-hash.js","sourceRoot":"","sources":["../../../src/registry/source-hash.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,OAAO,UAAU,MAAM,EAAE,CAAC;AAC5B,CAAC"}

package/dist/src/registry/types.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Type definitions for the v0.7 schema-side registry surface.
+ *
+ * This module is **types only** — no functions, no constants beyond
+ * what TypeScript requires for the type definitions themselves. All
+ * runtime behavior (registry construction, diff classification,
+ * freshness verdict computation, generation planning) lives in the
+ * sibling modules that import these types.
+ *
+ * Boundary recap (Master plan Decision #1):
+ * - `@nekostack/schema` is **pure** — no `fs.*`, no `import()`, no
+ *   `process.*`, no `console.*`. Takes data, returns data.
+ * - `@nekostack/cli` is the **filesystem shell** — loads schema files
+ *   via `tsx`, reads source bytes, reads committed artifacts, writes
+ *   regenerated artifacts, owns stdout / stderr / exit codes.
+ *
+ * Re-exported from the package-internal integration subpath
+ * `@nekostack/schema/cli` (Master plan Decision #10). Root
+ * `@nekostack/schema` does NOT expose these names.
+ */
+import type { SchemaNode } from "../ir/nodes.js";
+import type { AnySchema } from "../builders/schema.js";
+import type { IssuePath, Result } from "../errors/issue.js";
+/**
+ * One discovered `*.schema.{ts,js}` source file, after the CLI has
+ * read its bytes and dynamic-imported it via `tsx`.
+ *
+ * `schemas` is the array of every `export const X = s.object(...)`
+ * (or any other `Schema` instance) the file exposes. A file may
+ * legitimately declare more than one schema; the registry indexes
+ * each.
+ */
+export interface RegistrySourceEntry {
+    readonly sourcePath: string;
+    readonly sourceText: string;
+    readonly schemas: readonly AnySchema[];
+}
+/**
+ * One indexed schema. The registry stores these by
+ * `(schemaId, schemaVersion)` (Master plan Decision #4).
+ *
+ * `schemaVersion` is `undefined` when the source schema omitted
+ * `.version(...)`. In the `Registry` map's inner key the version is
+ * stored as the empty string `""` for the unversioned case, so the
+ * lookup type stays uniform.
+ */
+export interface RegistryEntry {
+    readonly schemaId: string;
+    readonly schemaVersion: string | undefined;
+    readonly irHash: `sha256:${string}`;
+    readonly sourceHash: `sha256:${string}`;
+    readonly sourcePath: string;
+    readonly schema: AnySchema;
+}
+/**
+ * Two-level map: outer key is `schemaId`, inner key is `schemaVersion`
+ * (or the empty string `""` for an entry whose source did not call
+ * `.version(...)`). `buildRegistry` is the only legitimate producer
+ * of `Registry` values; downstream callers treat them as opaque.
+ */
+export type Registry = ReadonlyMap<string, ReadonlyMap<string, RegistryEntry>>;
+/**
+ * Severity of a single `DiffChange`. The `worstSeverity` field on
+ * `DiffResult` is the max over a change set, with `breaking` >
+ * `additive` > `cosmetic`. Master plan Decision #11 + #12 lock the
+ * classification table; this enum is the column header.
+ */
+export type DiffSeverity = "breaking" | "additive" | "cosmetic";
+/**
+ * What kind of change a `DiffChange` represents. The shape of change
+ * — not its severity. Locked per Master plan Decision #12; severity
+ * for each kind depends on which row of the table the specific
+ * before/after pair lands on.
+ */
+export type DiffKind = "field_added" | "field_removed" | "refinement_changed" | "unknown_keys_changed" | "enum_value_added" | "enum_value_removed" | "literal_changed" | "default_added" | "default_removed" | "default_value_changed" | "absence_modifier_changed" | "metadata_changed" | "refinements_reordered" | "schema_version_changed" | "type_changed";
+export interface DiffChange {
+    readonly severity: DiffSeverity;
+    readonly path: IssuePath;
+    readonly kind: DiffKind;
+    readonly before?: unknown;
+    readonly after?: unknown;
+    readonly message: string;
+}
+/**
+ * The per-artifact outcome of the two-hash freshness matrix
+ * (Master plan §"Freshness verdict — two-hash discipline").
+ *
+ * - `clean`           — both hashes match the schema source.
+ * - `cosmetic_drift`  — sourceHash differs, irHash matches. Source
+ *                       text edited without semantic effect. CLI
+ *                       prints a stderr warning; CI still passes.
+ * - `stale`           — irHash differs. Regenerate required. CLI
+ *                       exits 1.
+ * - `integrity_error` — sourceHash matches, irHash differs. The
+ *                       impossible row of the matrix; if the artifact
+ *                       was generated from the recorded source text,
+ *                       irHash must match too. Indicates a manual
+ *                       artifact edit, provenance tampering, or
+ *                       hash inconsistency. CLI exits 4 and refuses
+ *                       to auto-regenerate.
+ */
+export type FreshnessVerdict = {
+    readonly status: "clean";
+    readonly artifactPath: string;
+} | {
+    readonly status: "cosmetic_drift";
+    readonly artifactPath: string;
+} | {
+    readonly status: "stale";
+    readonly artifactPath: string;
+} | {
+    readonly status: "integrity_error";
+    readonly artifactPath: string;
+};
+/**
+ * The four artifact kinds `generateHandler` plans for every schema
+ * in v0.7. Partial generation (subset of kinds) is explicitly NOT
+ * supported in v0.7 — `generate` writes all four; `check` expects
+ * all four (Master plan Decision #6).
+ */
+export type GeneratorKind = "typescript" | "zod" | "jsonSchema" | "openApi";
+/**
+ * One emit-ready artifact returned by `generateHandler`. The
+ * schema-side handler does NOT write the file; it returns the
+ * payload and the path the CLI should write it at. The
+ * `suggestedPath` is relative to the source schema's directory and
+ * follows the `<schema-dir>/generated/<basename>.<kind>` convention
+ * locked in Master plan Decision #6.
+ */
+export interface GeneratedArtifact {
+    readonly schemaId: string;
+    readonly kind: GeneratorKind;
+    readonly suggestedPath: string;
+    readonly content: string;
+    readonly irHash: `sha256:${string}`;
+    readonly sourceHash: `sha256:${string}`;
+}
+/**
+ * One on-disk artifact whose bytes the CLI has already read. The
+ * handler parses the provenance block (JSDoc header for TS/Zod;
+ * `x-nekostack` for JSON Schema / OpenAPI), compares against the
+ * current schema source, and emits a `FreshnessVerdict`.
+ */
+export interface CommittedArtifact {
+    readonly path: string;
+    readonly content: string;
+}
+export interface GenerateOpts {
+    readonly entries: readonly RegistrySourceEntry[];
+}
+export type GenerateResult = Result<{
+    readonly artifacts: readonly GeneratedArtifact[];
+}>;
+export interface CheckOpts {
+    /**
+     * Already-built registry. The CLI calls `buildRegistry` once,
+     * handles duplicate-detection failures upstream, and passes the
+     * same `Registry` to every handler (list / diff / check / generate).
+     */
+    readonly registry: Registry;
+    /**
+     * Already-read generated artifacts. The CLI owns filesystem reads;
+     * `checkHandler` only parses content and classifies freshness via
+     * the two-hash matrix.
+     */
+    readonly committedArtifacts: readonly CommittedArtifact[];
+}
+export type CheckResult = Result<{
+    readonly verdicts: readonly FreshnessVerdict[];
+}>;
+export interface DiffOpts {
+    readonly before: SchemaNode;
+    readonly after: SchemaNode;
+}
+export type DiffResult = Result<{
+    readonly changes: readonly DiffChange[];
+    readonly worstSeverity: DiffSeverity | null;
+}>;
+export interface ListOpts {
+    readonly registry: Registry;
+}
+export type ListResult = Result<{
+    readonly entries: readonly RegistryEntry[];
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/src/registry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/registry/types.ts"],"names":[],"mappings":"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"}

package/dist/src/registry/types.js

@@ -0,0 +1,22 @@
+/**
+ * Type definitions for the v0.7 schema-side registry surface.
+ *
+ * This module is **types only** — no functions, no constants beyond
+ * what TypeScript requires for the type definitions themselves. All
+ * runtime behavior (registry construction, diff classification,
+ * freshness verdict computation, generation planning) lives in the
+ * sibling modules that import these types.
+ *
+ * Boundary recap (Master plan Decision #1):
+ * - `@nekostack/schema` is **pure** — no `fs.*`, no `import()`, no
+ *   `process.*`, no `console.*`. Takes data, returns data.
+ * - `@nekostack/cli` is the **filesystem shell** — loads schema files
+ *   via `tsx`, reads source bytes, reads committed artifacts, writes
+ *   regenerated artifacts, owns stdout / stderr / exit codes.
+ *
+ * Re-exported from the package-internal integration subpath
+ * `@nekostack/schema/cli` (Master plan Decision #10). Root
+ * `@nekostack/schema` does NOT expose these names.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/registry/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/registry/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}