@nekostack/schema 1.0.0

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

@@ -0,0 +1,181 @@
+/**
+ * `checkHandler({ registry, committedArtifacts })` — freshness check
+ * via the two-hash matrix from Master plan §"Freshness verdict —
+ * two-hash discipline".
+ *
+ * Pure. No filesystem, no `import()`, no `process.*`, no `console.*`.
+ * The CLI reads each artifact's bytes from disk and hands them in;
+ * this function parses provenance, looks up the matching
+ * `RegistryEntry`, and produces one `FreshnessVerdict` per artifact.
+ * Master plan Decision #1 boundary.
+ *
+ * ## Two-hash matrix
+ *
+ * | artifact irHash | artifact sourceHash | verdict |
+ * |---|---|---|
+ * | matches registry | matches registry | `clean` |
+ * | matches registry | **differs**      | `cosmetic_drift` |
+ * | **differs**     | **differs**       | `stale` |
+ * | **differs**     | matches registry  | `integrity_error` (the impossible row — should never happen unless the artifact was hand-edited or the recorded sourceHash was tampered with) |
+ *
+ * ## v0.6 backward compatibility (Master plan Decision #8)
+ *
+ * Artifacts emitted before Step 4 (`@nekostack/schema@0.6.0` and
+ * earlier) have no `sourceHash` field/line. `parseProvenanceFromText`
+ * returns `sourceHash: undefined` for those. Treat as:
+ *
+ * - `irHash` matches registry → `clean`
+ * - `irHash` differs from registry → `stale`
+ *
+ * Absent `sourceHash` is **never** an integrity error by itself — the
+ * artifact simply predates the two-hash discipline. Once the user
+ * regenerates the artifact at v0.7+, full matrix participation
+ * resumes.
+ *
+ * ## Failure paths (Result<...> failure)
+ *
+ * - **Malformed provenance** — `parseProvenanceFromText` already
+ *   returns an `integrity_error` Issue; this handler forwards those
+ *   issues with the artifact path attached.
+ * - **Anonymous artifact** (provenance `schemaId === null`) —
+ *   `schema_not_found` with `metadata.reason = "anonymous_artifact"`.
+ *   The registry never indexes anonymous schemas (Master plan
+ *   Decision #5), so there's nothing to validate against.
+ * - **schemaId not in registry** — `schema_not_found`. The user
+ *   likely deleted a schema source file but forgot to delete the
+ *   generated artifacts.
+ * - **schemaId present but version not in registry** —
+ *   `version_not_found`. Distinct code so the CLI can format
+ *   orphan-by-id vs. orphan-by-version differently.
+ *
+ * Any artifact failure surfaces as `Result.failure` for the whole
+ * check call. Per-artifact verdicts are returned only when EVERY
+ * artifact parses + resolves cleanly.
+ */
+import { findSchema } from "../build-registry.js";
+import { parseProvenanceFromText } from "../parse-provenance.js";
+export function checkHandler(opts) {
+    const verdicts = [];
+    const issues = [];
+    for (const artifact of opts.committedArtifacts) {
+        const r = classifyArtifact(artifact, opts.registry);
+        if (r.kind === "verdict") {
+            verdicts.push(r.verdict);
+        }
+        else {
+            issues.push(...r.issues);
+        }
+    }
+    if (issues.length > 0) {
+        return { success: false, issues };
+    }
+    return { success: true, data: { verdicts } };
+}
+function classifyArtifact(artifact, registry) {
+    // 1. Parse provenance. Forward failures with the artifact path.
+    const parsed = parseProvenanceFromText(artifact.content);
+    if (!parsed.success) {
+        return {
+            kind: "issues",
+            issues: parsed.issues.map((i) => ({
+                ...i,
+                path: [artifact.path],
+                metadata: { ...(i.metadata ?? {}), artifactPath: artifact.path },
+            })),
+        };
+    }
+    const { schemaId, schemaVersion, irHash, sourceHash } = parsed.data;
+    // 2. Anonymous artifact — registry never indexes anonymous schemas.
+    if (schemaId === null) {
+        return {
+            kind: "issues",
+            issues: [
+                {
+                    code: "schema_not_found",
+                    path: [artifact.path],
+                    message: `Anonymous artifact \`${artifact.path}\` cannot be validated; registry does not index anonymous schemas.`,
+                    severity: "error",
+                    metadata: {
+                        reason: "anonymous_artifact",
+                        artifactPath: artifact.path,
+                    },
+                },
+            ],
+        };
+    }
+    // 3. Look up the (schemaId, schemaVersion) pair in the registry.
+    // Pass the version explicitly so `findSchema` does exact-match
+    // rather than highest-semver fallback.
+    const versionKey = schemaVersion ?? "";
+    const entry = findSchema(registry, schemaId, versionKey);
+    if (entry === undefined) {
+        const idKnown = registry.has(schemaId);
+        return {
+            kind: "issues",
+            issues: [
+                idKnown
+                    ? versionNotFoundIssue(artifact, schemaId, schemaVersion)
+                    : schemaNotFoundIssue(artifact, schemaId, schemaVersion),
+            ],
+        };
+    }
+    // 4. Apply the two-hash matrix.
+    return { kind: "verdict", verdict: verdictFor(artifact, irHash, sourceHash, entry) };
+}
+function verdictFor(artifact, artifactIrHash, artifactSourceHash, entry) {
+    const irMatch = artifactIrHash === entry.irHash;
+    // v0.6-era artifact: no sourceHash recorded.
+    // - irHash match → clean
+    // - irHash differ → stale
+    // Never integrity_error.
+    if (artifactSourceHash === undefined) {
+        return {
+            status: irMatch ? "clean" : "stale",
+            artifactPath: artifact.path,
+        };
+    }
+    const sourceMatch = artifactSourceHash === entry.sourceHash;
+    let status;
+    if (irMatch && sourceMatch)
+        status = "clean";
+    else if (irMatch && !sourceMatch)
+        status = "cosmetic_drift";
+    else if (!irMatch && !sourceMatch)
+        status = "stale";
+    else
+        status = "integrity_error";
+    return { status, artifactPath: artifact.path };
+}
+// =============================================================================
+// Issue constructors
+// =============================================================================
+function schemaNotFoundIssue(artifact, schemaId, schemaVersion) {
+    return {
+        code: "schema_not_found",
+        path: [artifact.path],
+        message: `Schema \`${schemaId}\` referenced by artifact \`${artifact.path}\` is not in the registry. ` +
+            `The schema source may have been deleted; remove the generated artifact or restore the source.`,
+        severity: "error",
+        metadata: {
+            artifactPath: artifact.path,
+            schemaId,
+            schemaVersion: schemaVersion ?? null,
+        },
+    };
+}
+function versionNotFoundIssue(artifact, schemaId, schemaVersion) {
+    const versionLabel = schemaVersion === null ? "(unversioned)" : `v${schemaVersion}`;
+    return {
+        code: "version_not_found",
+        path: [artifact.path],
+        message: `Schema \`${schemaId}\` exists in the registry but version \`${versionLabel}\` (referenced by \`${artifact.path}\`) does not. ` +
+            `Regenerate the artifact against the current schema versions.`,
+        severity: "error",
+        metadata: {
+            artifactPath: artifact.path,
+            schemaId,
+            schemaVersion: schemaVersion ?? null,
+        },
+    };
+}
+//# sourceMappingURL=check.js.map

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

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

package/dist/src/registry/handlers/diff.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `diffHandler({ before, after })` — wraps Step 7's `diffNodes` and
+ * adds the `worstSeverity` aggregation that Master plan Decision #13
+ * relies on for CLI exit-code mapping.
+ *
+ * Pure. No filesystem, no `import()`, no `process.*`, no `console.*`.
+ * Master plan Decision #1 boundary.
+ *
+ * **Severity precedence**: `breaking` > `additive` > `cosmetic`. The
+ * `worstSeverity` field is `null` exactly when `changes.length === 0`.
+ * Per Decision #13: a `schemaVersion`-only change paired with
+ * structural changes inherits the worst structural severity — that
+ * rule is realized naturally here because every change keeps its own
+ * severity (set by `diffNodes`); `worstSeverity` is the max over the
+ * full list.
+ *
+ * **`UnsupportedNodeKindError` propagates.** When `diffNodes` throws
+ * for an unsupported IR kind (`date`, `union`, `recursiveRef`,
+ * `transform`), this handler does NOT catch — it lets the throw
+ * propagate to the CLI dispatcher (Step 28+), where it maps to a
+ * non-zero exit code at the CLI boundary. This matches Master plan
+ * Decision #14's "throw at the boundary" language and the v0.6
+ * convention (`runtime/parse.ts` also propagates rather than
+ * normalizing into `Result`). Treating an unsupported IR kind as an
+ * `integrity_error` (the closest existing v0.7 code) would be
+ * semantically wrong — the IR is well-formed; v0.7 just doesn't
+ * know how to diff it. Inventing a new code (`schema_diff_failed`)
+ * without it being in the locked plan would expand the v0.7 vocabulary
+ * casually.
+ */
+import type { DiffOpts, DiffResult } from "../types.js";
+export declare function diffHandler(opts: DiffOpts): DiffResult;
+//# sourceMappingURL=diff.d.ts.map

package/dist/src/registry/handlers/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../../../src/registry/handlers/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAEV,QAAQ,EACR,UAAU,EAEX,MAAM,aAAa,CAAC;AAErB,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAStD"}

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

@@ -0,0 +1,61 @@
+/**
+ * `diffHandler({ before, after })` — wraps Step 7's `diffNodes` and
+ * adds the `worstSeverity` aggregation that Master plan Decision #13
+ * relies on for CLI exit-code mapping.
+ *
+ * Pure. No filesystem, no `import()`, no `process.*`, no `console.*`.
+ * Master plan Decision #1 boundary.
+ *
+ * **Severity precedence**: `breaking` > `additive` > `cosmetic`. The
+ * `worstSeverity` field is `null` exactly when `changes.length === 0`.
+ * Per Decision #13: a `schemaVersion`-only change paired with
+ * structural changes inherits the worst structural severity — that
+ * rule is realized naturally here because every change keeps its own
+ * severity (set by `diffNodes`); `worstSeverity` is the max over the
+ * full list.
+ *
+ * **`UnsupportedNodeKindError` propagates.** When `diffNodes` throws
+ * for an unsupported IR kind (`date`, `union`, `recursiveRef`,
+ * `transform`), this handler does NOT catch — it lets the throw
+ * propagate to the CLI dispatcher (Step 28+), where it maps to a
+ * non-zero exit code at the CLI boundary. This matches Master plan
+ * Decision #14's "throw at the boundary" language and the v0.6
+ * convention (`runtime/parse.ts` also propagates rather than
+ * normalizing into `Result`). Treating an unsupported IR kind as an
+ * `integrity_error` (the closest existing v0.7 code) would be
+ * semantically wrong — the IR is well-formed; v0.7 just doesn't
+ * know how to diff it. Inventing a new code (`schema_diff_failed`)
+ * without it being in the locked plan would expand the v0.7 vocabulary
+ * casually.
+ */
+import { diffNodes } from "../diff.js";
+export function diffHandler(opts) {
+    const changes = diffNodes(opts.before, opts.after);
+    return {
+        success: true,
+        data: {
+            changes,
+            worstSeverity: computeWorstSeverity(changes),
+        },
+    };
+}
+// =============================================================================
+// worstSeverity aggregation (Master plan Decision #13)
+// =============================================================================
+const SEVERITY_RANK = {
+    cosmetic: 0,
+    additive: 1,
+    breaking: 2,
+};
+function computeWorstSeverity(changes) {
+    if (changes.length === 0)
+        return null;
+    let worst = "cosmetic";
+    for (const c of changes) {
+        if (SEVERITY_RANK[c.severity] > SEVERITY_RANK[worst]) {
+            worst = c.severity;
+        }
+    }
+    return worst;
+}
+//# sourceMappingURL=diff.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../../../src/registry/handlers/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAQvC,MAAM,UAAU,WAAW,CAAC,IAAc;IACxC,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACnD,OAAO;QACL,OAAO,EAAE,IAAI;QACb,IAAI,EAAE;YACJ,OAAO;YACP,aAAa,EAAE,oBAAoB,CAAC,OAAO,CAAC;SAC7C;KACF,CAAC;AACJ,CAAC;AAED,gFAAgF;AAChF,uDAAuD;AACvD,gFAAgF;AAEhF,MAAM,aAAa,GAAiC;IAClD,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;CACZ,CAAC;AAEF,SAAS,oBAAoB,CAC3B,OAA8B;IAE9B,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACtC,IAAI,KAAK,GAAiB,UAAU,CAAC;IACrC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YACrD,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC;QACrB,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/registry/handlers/generate.d.ts

@@ -0,0 +1,87 @@
+/**
+ * `generateHandler({ entries })` — pure generation planner.
+ *
+ * For every **named** schema in every `RegistrySourceEntry`, emits
+ * all four artifact kinds (TypeScript / Zod / JSON Schema / OpenAPI)
+ * as `GeneratedArtifact` payloads with `suggestedPath`s relative to
+ * the schema's source location. The CLI is responsible for writing
+ * each payload to its suggested path; this handler never touches
+ * the filesystem.
+ *
+ * Master plan Decision #1 boundary: pure, data-in / data-out. No
+ * `fs.*`, no `import()`, no `process.*`, no `console.*`. The
+ * `sourceText` is hashed once per entry via `sourceHashFromText`
+ * (Step 2). `sourceHash` is passed through to each generator's
+ * `ProvenanceOptions` (Step 3 + Step 4) so the emitted artifact
+ * bytes carry provenance; `irHash(schema.node)` is recorded
+ * separately on each `GeneratedArtifact` and independently emitted
+ * by the generators from `schema.node` — the irHash field is NOT
+ * part of `ProvenanceOptions`.
+ *
+ * **Anonymous schemas (no `.id()`)** are silently skipped — they
+ * cannot participate in registry lookup downstream, so emitting
+ * artifacts for them is meaningless. The CLI warns; this handler
+ * is silent (Master plan Decision #5).
+ *
+ * **Partial generation is not supported in v0.7** (Master plan
+ * Decision #6). `GenerateOpts` carries no `kinds` filter; every
+ * named schema produces exactly 4 artifacts. The CLI's `check`
+ * verb expects all 4 to be present on disk.
+ *
+ * ## Suggested path convention (Master plan Decision #6 locked)
+ *
+ * **Single named schema in a source file:**
+ *
+ *   <schema-dir>/<basename>.schema.{ts,js}
+ *     ↓
+ *   <schema-dir>/generated/<basename>.types.ts
+ *   <schema-dir>/generated/<basename>.zod.ts
+ *   <schema-dir>/generated/<basename>.json.schema.json
+ *   <schema-dir>/generated/<basename>.openapi.json
+ *
+ * **Multiple named schemas in one source file** — paths gain a
+ * schemaId-derived discriminator slug so the four-artifact set per
+ * schema doesn't collide on disk:
+ *
+ *   <schema-dir>/<basename>.schema.ts
+ *     export const Tenant = s.object(...).id("com.x.Tenant");
+ *     export const Audit  = s.object(...).id("com.x.AuditEvent");
+ *     ↓
+ *   <schema-dir>/generated/<basename>.com-x-tenant.types.ts
+ *   <schema-dir>/generated/<basename>.com-x-auditevent.types.ts
+ *   <schema-dir>/generated/<basename>.com-x-tenant.zod.ts
+ *   ... and so on for json/openapi.
+ *
+ * Slug rule: lowercase, non-alphanumeric runs collapse to `-`, with
+ * leading/trailing `-` trimmed. If a source file declares the same
+ * `schemaId` at multiple versions (rare; v0.7 doesn't endorse but
+ * does tolerate), the discriminator additionally includes a slugged
+ * version (`com-x-tenant-1-0-0`) so per-schema paths stay unique.
+ *
+ * The basename strips a `.schema.{ts,js,mts,cts}` suffix when
+ * present; falls back to "filename minus last extension" otherwise.
+ * Source-path parsing is plain string manipulation — no `node:path`
+ * import — to keep the handler trivially platform-agnostic.
+ */
+import type { GenerateOpts, GenerateResult, GeneratorKind, RegistrySourceEntry } from "../types.js";
+declare const GENERATOR_KINDS: readonly GeneratorKind[];
+export declare function generateHandler(opts: GenerateOpts): GenerateResult;
+/**
+ * `<schema-dir>/<basename>.schema.ts` → `<schema-dir>/generated/<basename>[.<discriminator>].<ext>`.
+ *
+ * Pure string manipulation; no `node:path` import. Forward slashes
+ * are the canonical separator in the suggested path even on Windows
+ * — the CLI normalizes back to platform separators on write
+ * (separate concern; Step 31).
+ *
+ * The optional `discriminator` is inserted between the basename and
+ * the artifact extension. The handler computes it per-entry via
+ * `discriminatorsFor` (see above); callers that know they have a
+ * single-schema source file may omit the option entirely.
+ */
+export declare function suggestedPathFor(sourcePath: string, kind: GeneratorKind, options?: {
+    readonly discriminator?: string;
+}): string;
+export { GENERATOR_KINDS };
+export type { RegistrySourceEntry };
+//# sourceMappingURL=generate.d.ts.map

package/dist/src/registry/handlers/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../../src/registry/handlers/generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AAQH,OAAO,KAAK,EAEV,YAAY,EACZ,cAAc,EACd,aAAa,EACb,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAIrB,QAAA,MAAM,eAAe,EAAE,SAAS,aAAa,EAK5C,CAAC;AAEF,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,cAAc,CA6BlE;AAqGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,aAAa,EACnB,OAAO,GAAE;IAAE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAO,GAChD,MAAM,CAaR;AAaD,OAAO,EAAE,eAAe,EAAE,CAAC;AAG3B,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

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

@@ -0,0 +1,223 @@
+/**
+ * `generateHandler({ entries })` — pure generation planner.
+ *
+ * For every **named** schema in every `RegistrySourceEntry`, emits
+ * all four artifact kinds (TypeScript / Zod / JSON Schema / OpenAPI)
+ * as `GeneratedArtifact` payloads with `suggestedPath`s relative to
+ * the schema's source location. The CLI is responsible for writing
+ * each payload to its suggested path; this handler never touches
+ * the filesystem.
+ *
+ * Master plan Decision #1 boundary: pure, data-in / data-out. No
+ * `fs.*`, no `import()`, no `process.*`, no `console.*`. The
+ * `sourceText` is hashed once per entry via `sourceHashFromText`
+ * (Step 2). `sourceHash` is passed through to each generator's
+ * `ProvenanceOptions` (Step 3 + Step 4) so the emitted artifact
+ * bytes carry provenance; `irHash(schema.node)` is recorded
+ * separately on each `GeneratedArtifact` and independently emitted
+ * by the generators from `schema.node` — the irHash field is NOT
+ * part of `ProvenanceOptions`.
+ *
+ * **Anonymous schemas (no `.id()`)** are silently skipped — they
+ * cannot participate in registry lookup downstream, so emitting
+ * artifacts for them is meaningless. The CLI warns; this handler
+ * is silent (Master plan Decision #5).
+ *
+ * **Partial generation is not supported in v0.7** (Master plan
+ * Decision #6). `GenerateOpts` carries no `kinds` filter; every
+ * named schema produces exactly 4 artifacts. The CLI's `check`
+ * verb expects all 4 to be present on disk.
+ *
+ * ## Suggested path convention (Master plan Decision #6 locked)
+ *
+ * **Single named schema in a source file:**
+ *
+ *   <schema-dir>/<basename>.schema.{ts,js}
+ *     ↓
+ *   <schema-dir>/generated/<basename>.types.ts
+ *   <schema-dir>/generated/<basename>.zod.ts
+ *   <schema-dir>/generated/<basename>.json.schema.json
+ *   <schema-dir>/generated/<basename>.openapi.json
+ *
+ * **Multiple named schemas in one source file** — paths gain a
+ * schemaId-derived discriminator slug so the four-artifact set per
+ * schema doesn't collide on disk:
+ *
+ *   <schema-dir>/<basename>.schema.ts
+ *     export const Tenant = s.object(...).id("com.x.Tenant");
+ *     export const Audit  = s.object(...).id("com.x.AuditEvent");
+ *     ↓
+ *   <schema-dir>/generated/<basename>.com-x-tenant.types.ts
+ *   <schema-dir>/generated/<basename>.com-x-auditevent.types.ts
+ *   <schema-dir>/generated/<basename>.com-x-tenant.zod.ts
+ *   ... and so on for json/openapi.
+ *
+ * Slug rule: lowercase, non-alphanumeric runs collapse to `-`, with
+ * leading/trailing `-` trimmed. If a source file declares the same
+ * `schemaId` at multiple versions (rare; v0.7 doesn't endorse but
+ * does tolerate), the discriminator additionally includes a slugged
+ * version (`com-x-tenant-1-0-0`) so per-schema paths stay unique.
+ *
+ * The basename strips a `.schema.{ts,js,mts,cts}` suffix when
+ * present; falls back to "filename minus last extension" otherwise.
+ * Source-path parsing is plain string manipulation — no `node:path`
+ * import — to keep the handler trivially platform-agnostic.
+ */
+import { irHash } from "../../ir/hash.js";
+import { generateTypeScript } from "../../generators/ts.js";
+import { generateZod } from "../../generators/zod.js";
+import { generateJsonSchema } from "../../generators/json-schema.js";
+import { generateOpenApiSchemaComponent } from "../../generators/openapi.js";
+import { sourceHashFromText } from "../source-hash.js";
+const GENERATOR_KINDS = [
+    "typescript",
+    "zod",
+    "jsonSchema",
+    "openApi",
+];
+export function generateHandler(opts) {
+    const artifacts = [];
+    for (const entry of opts.entries) {
+        const entrySourceHash = sourceHashFromText(entry.sourceText);
+        const discriminators = discriminatorsFor(entry);
+        for (const schema of entry.schemas) {
+            const schemaId = schema.node.metadata?.id;
+            if (schemaId === undefined)
+                continue; // anonymous → skip
+            const schemaIrHash = `sha256:${irHash(schema.node)}`;
+            const discriminator = discriminators.get(schema);
+            for (const kind of GENERATOR_KINDS) {
+                artifacts.push({
+                    schemaId,
+                    kind,
+                    suggestedPath: suggestedPathFor(entry.sourcePath, kind, {
+                        ...(discriminator !== undefined ? { discriminator } : {}),
+                    }),
+                    content: renderArtifact(kind, schema, entrySourceHash),
+                    irHash: schemaIrHash,
+                    sourceHash: entrySourceHash,
+                });
+            }
+        }
+    }
+    return { success: true, data: { artifacts } };
+}
+// =============================================================================
+// Per-entry discriminator slugs (Master plan Decision #6 multi-schema rule)
+// =============================================================================
+/**
+ * For one `RegistrySourceEntry`, decide the discriminator slug each
+ * named schema needs on its `suggestedPath`:
+ *
+ * - Entry contains exactly 0 or 1 named schemas → no discriminator.
+ * - Entry contains 2+ named schemas with **distinct ids** →
+ *   discriminator = `slugify(schemaId)`.
+ * - Entry contains 2+ named schemas where **at least one id appears
+ *   more than once** (different versions of the same id in one
+ *   source file — rare) → for the IDs that repeat, the discriminator
+ *   additionally embeds the slugged version so per-schema paths
+ *   stay unique. IDs that appear only once still use the id-only
+ *   slug.
+ *
+ * Returned `Map` is keyed by the original `AnySchema` instance so
+ * the handler loop can look up each schema's discriminator without
+ * re-deriving it. Anonymous schemas are not represented in the map.
+ */
+function discriminatorsFor(entry) {
+    const result = new Map();
+    const named = entry.schemas.filter((s) => s.node.metadata?.id !== undefined);
+    if (named.length <= 1) {
+        for (const s of named)
+            result.set(s, undefined);
+        return result;
+    }
+    // Multiple named schemas — disambiguation needed. Count id
+    // occurrences; if any id appears more than once, those entries
+    // get the version-suffixed slug to stay unique.
+    const idCounts = new Map();
+    for (const s of named) {
+        const id = s.node.metadata.id;
+        idCounts.set(id, (idCounts.get(id) ?? 0) + 1);
+    }
+    for (const s of named) {
+        const id = s.node.metadata.id;
+        const version = s.node.metadata?.version;
+        const idSlug = slugify(id);
+        const sameIdElsewhere = (idCounts.get(id) ?? 0) > 1;
+        const slug = sameIdElsewhere && version !== undefined
+            ? `${idSlug}-${slugify(version)}`
+            : idSlug;
+        result.set(s, slug);
+    }
+    return result;
+}
+/** Lowercase, non-alphanumeric runs → `-`, trim leading/trailing `-`. */
+function slugify(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+// =============================================================================
+// Per-kind dispatch
+// =============================================================================
+function renderArtifact(kind, schema, sourceHash) {
+    const node = schema.node;
+    switch (kind) {
+        case "typescript":
+            return generateTypeScript(node, { sourceHash });
+        case "zod":
+            return generateZod(node, { sourceHash });
+        case "jsonSchema":
+            return generateJsonSchema(node, { sourceHash });
+        case "openApi":
+            return generateOpenApiSchemaComponent(node, { sourceHash });
+    }
+}
+// =============================================================================
+// Path convention
+// =============================================================================
+const KIND_TO_EXT = {
+    typescript: ".types.ts",
+    zod: ".zod.ts",
+    jsonSchema: ".json.schema.json",
+    openApi: ".openapi.json",
+};
+/**
+ * `<schema-dir>/<basename>.schema.ts` → `<schema-dir>/generated/<basename>[.<discriminator>].<ext>`.
+ *
+ * Pure string manipulation; no `node:path` import. Forward slashes
+ * are the canonical separator in the suggested path even on Windows
+ * — the CLI normalizes back to platform separators on write
+ * (separate concern; Step 31).
+ *
+ * The optional `discriminator` is inserted between the basename and
+ * the artifact extension. The handler computes it per-entry via
+ * `discriminatorsFor` (see above); callers that know they have a
+ * single-schema source file may omit the option entirely.
+ */
+export function suggestedPathFor(sourcePath, kind, options = {}) {
+    const normalized = sourcePath.replace(/\\/g, "/");
+    const lastSlash = normalized.lastIndexOf("/");
+    const dir = lastSlash >= 0 ? normalized.slice(0, lastSlash) : "";
+    const filename = lastSlash >= 0 ? normalized.slice(lastSlash + 1) : normalized;
+    const basename = basenameOf(filename);
+    const stem = options.discriminator !== undefined
+        ? `${basename}.${options.discriminator}`
+        : basename;
+    const prefix = dir ? `${dir}/generated/${stem}` : `generated/${stem}`;
+    return `${prefix}${KIND_TO_EXT[kind]}`;
+}
+function basenameOf(filename) {
+    // Preferred: strip the `.schema.{ts,js,mts,cts}` suffix.
+    const schemaMatch = filename.match(/^(.+?)\.schema\.(ts|js|mts|cts)$/);
+    if (schemaMatch)
+        return schemaMatch[1];
+    // Fallback for non-conventional input: drop the last extension.
+    const lastDot = filename.lastIndexOf(".");
+    return lastDot > 0 ? filename.slice(0, lastDot) : filename;
+}
+// Exported so the CLI can advertise the same path convention for
+// `check`'s artifact-lookup, without re-deriving the rule.
+export { GENERATOR_KINDS };
+//# sourceMappingURL=generate.js.map

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

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

package/dist/src/registry/handlers/list.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `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.
+ */
+import type { ListOpts, ListResult } from "../types.js";
+export declare function listHandler(opts: ListOpts): ListResult;
+//# sourceMappingURL=list.d.ts.map

package/dist/src/registry/handlers/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/registry/handlers/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EAEX,MAAM,aAAa,CAAC;AAErB,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAyBtD"}