@intentius/chant-lexicon-cedar 0.124.31 → 0.124.33

package/dist/codegen/docs.js

@@ -0,0 +1,133 @@
+/**
+ * The cedar lexicon's Starlight site.
+ *
+ * Prose pages are authored under `docs/pages/*.mdx`, each tagged with a
+ * Diátaxis quadrant (chant #1731/#1733); the pipeline builds the sidebar from
+ * that tag. Two more pages come out of the pipeline itself: the generated
+ * rules table (`rules`) and the serialization reference. Both are linked from
+ * the sidebar automatically.
+ *
+ * Cross-namespace links are written as full `/chant/...` paths. This site's
+ * base is `/chant/lexicons/cedar/`, so a bare `/guide/...` would be rewritten
+ * to `/chant/lexicons/cedar/guide/...`; the rehype plugin's idempotency check
+ * leaves an already-project-rooted path alone. Sibling pages use `../slug/`,
+ * because `./slug` from an MDX body resolves as a child.
+ */
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+// ── index ─────────────────────────────────────────────────────────
+const overview = `The **cedar** lexicon is the typed authoring layer above [Cedar](https://www.cedarpolicy.com/), the vendor-neutral authorization policy language that joined the CNCF as a Sandbox project in December 2025.
+
+Cedar is deliberately abstraction-free: no variables, no modules, no loops, and templates carrying exactly two slots (\`?principal\`, \`?resource\`). Its own toolchain validates and evaluates — it checks policies after they are written and decides requests at runtime. Everything upstream of the policy text is unowned, which is where this lexicon lives.
+
+\`\`\`bash
+npm install --save-dev @intentius/chant-lexicon-cedar
+\`\`\`
+
+## Quick start
+
+\`\`\`typescript
+import { Policy, ReadAction } from "@intentius/chant-lexicon-cedar";
+
+export const ownerRead = new Policy({
+  effect: "permit",
+  principal: { is: "App::User" },
+  action: { eq: ReadAction },
+  resource: { is: "App::Document" },
+  when: ["resource.owner == principal"],
+});
+\`\`\`
+
+\`ReadAction\` and \`"App::User"\` are generated from *your* Cedar schema, so a
+renamed entity type is a compiler-guided refactor and a typo'd action is a
+compile error — not a validation failure after the text is written.
+
+## What comes out
+
+| File | Who reads it |
+|------|--------------|
+| \`<name>.cedar\` | Every Cedar evaluator — Amazon Verified Permissions, cedar-agent, an embedded \`cedar-wasm\` |
+| \`policies.cedar.json\` | The Cedar JSON policy format; also the parse source for import |
+
+chant appears in neither. An emitted policy set walks away and is consumed by
+any evaluator with chant nowhere in sight.
+
+## Cedar is a target, never a gate
+
+There is no \`cedarGate()\` and there will not be one.
+[Organizational policy](/chant/guide/organizational-policy/) in chant is
+TypeScript post-synth checks; a second policy engine would duplicate the lint
+engine. chant compiles *to* Cedar; it is not governed *by* Cedar.
+
+## The dogwood dialect
+
+Cedar with temporal operators, shipping inside this lexicon as a pre-release
+surface under the \`DWD\` id family: a policy that can depend on what already
+happened in a session. Start at [The Dogwood Dialect](./dogwood), which is
+honest about upstream's governance before it shows you a builder.`;
+// ── Output format, for the generated serialization page ───────────
+const outputFormat = `The cedar lexicon emits two views of one policy set.
+
+**\`<name>.cedar\`** — the primary output, and the surface every Cedar evaluator reads.
+
+\`\`\`cedar
+@id("owner-read")
+@doc("Owners always read their own documents.")
+permit (
+  principal is App::User,
+  action in [App::Action::"read", App::Action::"list"],
+  resource is App::Document
+)
+when { resource.owner == principal };
+\`\`\`
+
+**\`policies.cedar.json\`** — the Cedar JSON policy format, written alongside.
+
+\`\`\`json
+{
+  "staticPolicies": {
+    "owner-read": {
+      "effect": "permit",
+      "principal": { "op": "is", "entity_type": "App::User" },
+      "action": { "op": "in", "entities": [{ "type": "App::Action", "id": "read" }] },
+      "resource": { "op": "is", "entity_type": "App::Document" },
+      "conditions": [{ "kind": "when", "body": { "__expr": "resource.owner == principal" } }],
+      "annotations": { "id": "owner-read" }
+    }
+  },
+  "templates": {},
+  "templateLinks": []
+}
+\`\`\`
+
+Both come from the same structured model in one pass, so they cannot drift. The
+JSON form is also the parse source for import — see [Importing](../importing/).
+`;
+/**
+ * Generate the docs site for the cedar lexicon.
+ */
+export async function generateDocs(options) {
+    const config = {
+        name: "cedar",
+        displayName: "Cedar",
+        description: "Typed authoring for Cedar authorization policies",
+        distDir: join(pkgDir, "dist"),
+        outDir: join(pkgDir, "docs"),
+        srcDir: join(pkgDir, "src"),
+        basePath: process.env.DOCS_BASE_PATH ?? "/chant/lexicons/cedar/",
+        overview,
+        outputFormat,
+        // Cedar declarations are namespaced `App::Document` and
+        // `App::Action::"read"`, so the first segment is the namespace — which is
+        // the only grouping a Cedar schema has.
+        serviceFromType: (type) => type.split("::")[0] ?? type,
+    };
+    const result = docsPipeline(config);
+    writeDocsSite(config, result);
+    if (options?.verbose) {
+        console.error(`Generated docs: ${result.pages.size} pages, ${result.stats.resources} resources, ` +
+            `${result.stats.properties} property types, ${result.stats.rules} rules`);
+    }
+}

package/dist/codegen/emit.js

@@ -0,0 +1,331 @@
+/**
+ * The three generated artifacts, all built from one model.
+ *
+ * `lexicon-cedar.json`, `index.ts` and `index.d.ts` describe the same set of
+ * declarations, and the only way they cannot skew is if they are derived from
+ * the same pass — which is what {@link buildEmitModel} is for. Nothing here
+ * reads the clock or a random source: keys come out of the resolved schema
+ * already sorted (Rust `BTreeMap`, #1648 §5.2), everything else is sorted
+ * explicitly, so regenerating twice produces identical bytes.
+ */
+import { deriveName, POLICY_TS_NAME, POLICY_TYPE } from "./naming.js";
+export const LEXICON_NAME = "cedar";
+/**
+ * Assign every generated name, once.
+ *
+ * `NamingStrategy` names the primary declarations; the derived record names
+ * are de-duplicated against the same pool so a `UserAttributes` entity type in
+ * the schema cannot quietly take the name `User`'s attribute record wants.
+ */
+export function buildEmitModel(decls, naming) {
+    const taken = new Set([POLICY_TS_NAME]);
+    const entities = [];
+    const actions = [];
+    const sorted = [...decls].sort((a, b) => a.typeName.localeCompare(b.typeName));
+    // Primary names first, all of them, before any derived name is claimed —
+    // otherwise `UserAttributes` (derived) could take the name an entity type
+    // literally called `UserAttributes` is entitled to.
+    const primaryNames = new Map();
+    for (const decl of sorted) {
+        const base = naming.resolve(decl.typeName);
+        if (!base)
+            continue;
+        // `NamingStrategy`'s last phase qualifies a collision with the service
+        // name, which for Cedar is the namespace — so two declarations in the
+        // *same* namespace that reduce to the same short name (an entity type
+        // `ReadAction` beside an action `read`) both come back as `AppReadAction`.
+        // Silently letting the second overwrite the first in the registry is the
+        // one outcome worth refusing.
+        primaryNames.set(decl.typeName, deriveName(base, "", taken));
+    }
+    for (const decl of sorted) {
+        const tsName = primaryNames.get(decl.typeName);
+        if (!tsName)
+            continue;
+        if (decl.kind === "entity") {
+            entities.push({
+                tsName,
+                typeName: decl.typeName,
+                namespace: decl.namespace,
+                attributesTsName: deriveName(tsName, "Attributes", taken),
+                uidTsName: deriveName(tsName, "Uid", taken),
+                memberOfTypes: decl.memberOfTypes,
+                attributes: decl.attributes,
+                ...(decl.enumValues ? { enumValues: decl.enumValues } : {}),
+            });
+        }
+        else {
+            actions.push({
+                tsName,
+                typeName: decl.typeName,
+                namespace: decl.namespace,
+                actionId: decl.actionId,
+                contextTsName: deriveName(stripActionSuffix(tsName), "Context", taken),
+                principalTypes: decl.principalTypes,
+                resourceTypes: decl.resourceTypes,
+                context: decl.context,
+            });
+        }
+    }
+    entities.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    actions.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    const uidTypeByEntityType = new Map();
+    for (const entity of entities)
+        uidTypeByEntityType.set(entity.typeName, entity.uidTsName);
+    return { entities, actions, uidTypeByEntityType };
+}
+/** `ReadAction` → `Read`, so the context type reads `ReadContext`. */
+function stripActionSuffix(tsName) {
+    return tsName.endsWith("Action") && tsName.length > "Action".length
+        ? tsName.slice(0, -"Action".length)
+        : tsName;
+}
+// ── TypeScript type rendering ─────────────────────────────────────
+/**
+ * Render one Cedar type as a TypeScript type expression.
+ *
+ * Extension types (`ipaddr`, `decimal`, `datetime`, `duration`) render as
+ * `string`: Cedar constructs them from string literals in policy text, and
+ * inventing branded TS types for values chant never evaluates would be
+ * decoration.
+ */
+export function renderType(type, model) {
+    switch (type.kind) {
+        case "primitive":
+            return type.ts;
+        case "entity":
+            return model.uidTypeByEntityType.get(type.entityType) ?? "string";
+        case "set": {
+            const inner = renderType(type.element, model);
+            return /[|&]/.test(inner) ? `Array<${inner}>` : `${inner}[]`;
+        }
+        case "record":
+            return type.attributes.length === 0
+                ? "Record<string, never>"
+                : `{ ${type.attributes.map((a) => `${propertyKey(a.name)}${a.required ? "" : "?"}: ${renderType(a.type, model)};`).join(" ")} }`;
+        case "extension":
+            return "string";
+        case "opaque":
+            return "string";
+    }
+}
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** Quote an attribute name that is not a bare identifier — Cedar allows both. */
+export function propertyKey(name) {
+    return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+/** The Cedar surface syntax for a type, for doc comments and the registry. */
+export function cedarTypeText(type) {
+    switch (type.kind) {
+        case "primitive":
+            return type.cedar;
+        case "entity":
+            return type.entityType;
+        case "set":
+            return `Set<${cedarTypeText(type.element)}>`;
+        case "record":
+            return `{ ${type.attributes.map((a) => `"${a.name}"${a.required ? "" : "?"}: ${cedarTypeText(a.type)}`).join(", ")} }`;
+        case "extension":
+            return type.name;
+        case "opaque":
+            return type.name;
+    }
+}
+/** `App::User` → `App::User.Attributes`, the record type's own spec name. */
+export function attributesTypeName(entityTypeName) {
+    return `${entityTypeName}.Attributes`;
+}
+/** `App::Action::"read"` → `App::Action::"read".Context`. */
+export function contextTypeName(actionTypeName) {
+    return `${actionTypeName}.Context`;
+}
+function attributeTable(attributes) {
+    const out = {};
+    for (const attr of [...attributes].sort((a, b) => a.name.localeCompare(b.name))) {
+        out[attr.name] = { type: cedarTypeText(attr.type), required: attr.required };
+    }
+    return out;
+}
+/** Build `lexicon-cedar.json`. */
+export function generateRegistry(model) {
+    const entries = {};
+    entries[POLICY_TS_NAME] = {
+        resourceType: POLICY_TYPE,
+        kind: "resource",
+        lexicon: LEXICON_NAME,
+        description: "A Cedar policy — the unit this lexicon serializes to .cedar text and the JSON policy format.",
+        properties: {
+            effect: { type: "permit | forbid", required: false },
+            principal: { type: "scope", required: false },
+            action: { type: "scope", required: false },
+            resource: { type: "scope", required: false },
+            when: { type: "Set<expression>", required: false },
+            unless: { type: "Set<expression>", required: false },
+            annotations: { type: "Record<String, String>", required: false },
+        },
+    };
+    for (const entity of model.entities) {
+        entries[entity.tsName] = {
+            resourceType: entity.typeName,
+            kind: "resource",
+            lexicon: LEXICON_NAME,
+            namespace: entity.namespace,
+            memberOfTypes: entity.memberOfTypes,
+            properties: attributeTable(entity.attributes),
+            ...(entity.enumValues ? { enumValues: entity.enumValues } : {}),
+        };
+        entries[entity.attributesTsName] = {
+            resourceType: attributesTypeName(entity.typeName),
+            kind: "property",
+            lexicon: LEXICON_NAME,
+            namespace: entity.namespace,
+            properties: attributeTable(entity.attributes),
+        };
+    }
+    for (const action of model.actions) {
+        entries[action.tsName] = {
+            resourceType: action.typeName,
+            kind: "resource",
+            lexicon: LEXICON_NAME,
+            namespace: action.namespace,
+            principalTypes: action.principalTypes,
+            resourceTypes: action.resourceTypes,
+            properties: attributeTable(action.context),
+        };
+        entries[action.contextTsName] = {
+            resourceType: contextTypeName(action.typeName),
+            kind: "property",
+            lexicon: LEXICON_NAME,
+            namespace: action.namespace,
+            properties: attributeTable(action.context),
+        };
+    }
+    const sorted = {};
+    for (const key of Object.keys(entries).sort())
+        sorted[key] = entries[key];
+    return JSON.stringify(sorted, null, 2) + "\n";
+}
+// ── Shared declaration bodies ─────────────────────────────────────
+const BANNER = "// Code generated by chant generate. DO NOT EDIT.";
+/** A template-literal type for an entity UID: `` `App::User::"${string}"` ``. */
+function uidTypeExpression(entityTypeName) {
+    return "`" + entityTypeName + '::"${string}"`';
+}
+function docBlock(lines, indent = "") {
+    if (lines.length === 0)
+        return [];
+    return [`${indent}/**`, ...lines.map((l) => `${indent} * ${l}`), `${indent} */`];
+}
+function attributeLines(attributes, model) {
+    return attributes.map((attr) => `  ${propertyKey(attr.name)}${attr.required ? "" : "?"}: ${renderType(attr.type, model)};`);
+}
+function unionOr(members, fallback) {
+    return members.length > 0 ? members.join(" | ") : fallback;
+}
+/**
+ * The shared body of `index.ts` and `index.d.ts` — everything that is
+ * type-level and therefore identical in both.
+ */
+function typeDeclarations(model) {
+    const lines = [];
+    for (const entity of model.entities) {
+        lines.push(...docBlock([
+            `Entity UID of \`${entity.typeName}\`.`,
+            ...(entity.memberOfTypes.length > 0 ? [`Member of: ${entity.memberOfTypes.join(", ")}.`] : []),
+        ]), `export type ${entity.uidTsName} = ${uidTypeExpression(entity.typeName)};`, "", `export interface ${entity.attributesTsName}Props {`, ...attributeLines(entity.attributes, model), "}", "");
+    }
+    for (const action of model.actions) {
+        lines.push(`export interface ${action.contextTsName}Props {`, ...attributeLines(action.context, model), "}", "");
+    }
+    lines.push("/** Every entity type name the schema declares, as Cedar writes it. */", `export type EntityTypeName = ${unionOr(model.entities.map((e) => JSON.stringify(e.typeName)), "never")};`, "", "/** Every entity UID the schema can produce. */", `export type EntityUid = ${unionOr(model.entities.map((e) => e.uidTsName), "never")};`, "", "/** Every action UID the schema declares. */", `export type ActionUid = ${unionOr(model.actions.map((a) => JSON.stringify(a.typeName)), "never")};`, "", "/** Anything a policy scope may name. */", "export type PolicyRef = EntityUid | ActionUid;", "", "/** A Cedar policy either permits or forbids; there is no third effect. */", 'export type PolicyEffect = "permit" | "forbid";', "", ...docBlock([
+        "One scope position (`principal`, `action`, `resource`).",
+        "",
+        "`{}` is the unconstrained form Cedar writes as a bare variable. The",
+        "constrained forms mirror the grammar: `== E`, `in E`, `in [E, …]`,",
+        "`is T`, and `is T in E`.",
+    ]), "export type PolicyScope =", "  | Record<string, never>", "  | { eq: PolicyRef; in?: never; is?: never }", "  | { in: PolicyRef | PolicyRef[]; eq?: never; is?: never }", "  | { is: EntityTypeName; in?: PolicyRef | PolicyRef[]; eq?: never };", "", ...docBlock([
+        "The props of a `Cedar::Policy`.",
+        "",
+        "`when`/`unless` carry Cedar expression text. They stay strings because",
+        "Cedar's expression grammar is the policy language itself — typing it in",
+        "TypeScript is import/reconcile's problem (epic #1645 sub-issue 6), not",
+        "codegen's.",
+    ]), "export interface PolicyProps {", "  /** Defaults to `permit` when omitted. */", "  effect?: PolicyEffect;", "  principal?: PolicyScope;", "  action?: PolicyScope;", "  resource?: PolicyScope;", "  /** Cedar expression strings, each emitted as its own `when { … }` clause. */", "  when?: string[];", "  /** Cedar expression strings, each emitted as its own `unless { … }` clause. */", "  unless?: string[];", "  /** Emitted as `@key(\"value\")`; an explicit `id` wins over the logical name. */", "  annotations?: Record<string, string>;", "}", "");
+    return lines;
+}
+// ── index.ts ──────────────────────────────────────────────────────
+/** Build the runtime `index.ts`. */
+export function generateRuntimeIndex(model) {
+    const lines = [
+        BANNER,
+        'import type { Declarable } from "@intentius/chant/declarable";',
+        'import { createProperty, createResource } from "./runtime";',
+        "",
+        ...typeDeclarations(model),
+        ...docBlock([
+            "The policy resource. Declare one per policy:",
+            "",
+            "```ts",
+            'export const allowOwnerRead = new Policy({',
+            '  principal: { is: "App::User" },',
+            "  action: { eq: ReadAction },",
+            "  when: ['resource.owner == principal'],",
+            "});",
+            "```",
+        ]),
+        `export const ${POLICY_TS_NAME} = createResource(${JSON.stringify(POLICY_TYPE)}, ${JSON.stringify(LEXICON_NAME)}, {}) as unknown as new (props: PolicyProps) => Declarable;`,
+        "",
+    ];
+    for (const entity of model.entities) {
+        lines.push(`export const ${entity.tsName} = createResource(${JSON.stringify(entity.typeName)}, ${JSON.stringify(LEXICON_NAME)}, {}) as unknown as new (props: ${entity.attributesTsName}Props) => Declarable;`, `export const ${entity.attributesTsName} = createProperty(${JSON.stringify(attributesTypeName(entity.typeName))}, ${JSON.stringify(LEXICON_NAME)}) as unknown as new (props: ${entity.attributesTsName}Props) => Declarable;`);
+    }
+    if (model.entities.length > 0)
+        lines.push("");
+    for (const action of model.actions) {
+        lines.push(...docBlock([
+            `\`${action.typeName}\`.`,
+            ...(action.principalTypes.length > 0 ? [`Principals: ${action.principalTypes.join(", ")}.`] : []),
+            ...(action.resourceTypes.length > 0 ? [`Resources: ${action.resourceTypes.join(", ")}.`] : []),
+        ]), `export const ${action.tsName} = ${JSON.stringify(action.typeName)} as const;`, `export const ${action.contextTsName} = createProperty(${JSON.stringify(contextTypeName(action.typeName))}, ${JSON.stringify(LEXICON_NAME)}) as unknown as new (props: ${action.contextTsName}Props) => Declarable;`);
+    }
+    if (model.actions.length > 0)
+        lines.push("");
+    lines.push("/** Every generated action constant, for exhaustive iteration. */", `export const ALL_ACTIONS: readonly ActionUid[] = [${model.actions.map((a) => a.tsName).join(", ")}];`, "", "/** Every entity type name the schema declares. */", `export const ALL_ENTITY_TYPES: readonly EntityTypeName[] = [${model.entities.map((e) => JSON.stringify(e.typeName)).join(", ")}];`, "");
+    return lines.join("\n");
+}
+// ── index.d.ts ────────────────────────────────────────────────────
+/**
+ * Build the declaration-only `index.d.ts`.
+ *
+ * It is validated standalone by core's `typecheckDTS`, which runs tsc in a
+ * temp directory with no `node_modules` beyond a stub for
+ * `@intentius/chant/declarable` — so this file may import that and nothing
+ * else, and every other type it uses has to be declared here.
+ */
+export function generateTypes(model) {
+    const lines = [
+        BANNER,
+        'import type { Declarable } from "@intentius/chant/declarable";',
+        "",
+        ...typeDeclarations(model),
+        `export declare const ${POLICY_TS_NAME}: new (props: PolicyProps) => Declarable;`,
+        "",
+    ];
+    for (const entity of model.entities) {
+        lines.push(`export declare const ${entity.tsName}: new (props: ${entity.attributesTsName}Props) => Declarable;`, `export declare const ${entity.attributesTsName}: new (props: ${entity.attributesTsName}Props) => Declarable;`);
+    }
+    if (model.entities.length > 0)
+        lines.push("");
+    for (const action of model.actions) {
+        lines.push(`export declare const ${action.tsName}: ${JSON.stringify(action.typeName)};`, `export declare const ${action.contextTsName}: new (props: ${action.contextTsName}Props) => Declarable;`);
+    }
+    if (model.actions.length > 0)
+        lines.push("");
+    lines.push("export declare const ALL_ACTIONS: readonly ActionUid[];", "export declare const ALL_ENTITY_TYPES: readonly EntityTypeName[];", "");
+    return lines.join("\n");
+}
+// ── runtime.ts ────────────────────────────────────────────────────
+/** The tiny re-export module `index.ts` imports its factories from. */
+export const RUNTIME_TS = `${BANNER}
+export { createProperty, createResource } from "@intentius/chant/runtime";
+`;

package/dist/codegen/generate-cli.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env tsx
+/**
+ * Entry point for `npm run generate` in lexicon-cedar.
+ *
+ * Generation reads the project's `.cedarschema` when there is one and the
+ * schema bundled at `src/spec/default-schema.cedarschema` when there is not
+ * (#1650), so this always has something to generate from and no longer needs
+ * the scaffold's swallow-and-continue guard.
+ *
+ * This script is the package's own build step, so the project root is the
+ * package root and the output is `src/generated/` (the monorepo case of
+ * `resolveGeneratedDir`). A consumer runs `chant generate --lexicon cedar`
+ * instead, which writes into the consumer's tree (#1696).
+ */
+import { generate, packageDir, resolveGeneratedDir, writeGeneratedFiles } from "./generate.js";
+const pkgDir = packageDir();
+const result = await generate({ verbose: true, projectRoot: pkgDir });
+writeGeneratedFiles(result, resolveGeneratedDir({ projectRoot: pkgDir }));

package/dist/codegen/generate.js

@@ -0,0 +1,122 @@
+/**
+ * Schema-driven code generation for the cedar lexicon (#1650).
+ *
+ * The pipeline is core's; what is unusual is its input. Every other lexicon
+ * fetches one global upstream spec, so `fetchSchemas` is an HTTP call and a
+ * cache. Cedar's spec-of-interest is the project's own `.cedarschema` (epic
+ * #1645), so `fetchSchemas` is a file read with a fallback, and the pinned
+ * upstream is the *grammar* — `@cedar-policy/cedar-wasm`, whose language
+ * version is asserted before anything is emitted.
+ *
+ * Order matters in {@link generate}: the language-version assert runs before
+ * the schema is resolved, because resolution is the thing whose output shape a
+ * grammar change would move.
+ */
+import { generatePipeline, writeGeneratedArtifacts } from "@intentius/chant/codegen/generate";
+import { existsSync, realpathSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+import { fileURLToPath } from "url";
+import { CEDAR_DEFAULT_OUT_DIR } from "../config.js";
+import { createNaming } from "./naming.js";
+import { buildEmitModel, generateRegistry, generateRuntimeIndex, generateTypes, RUNTIME_TS, } from "./emit.js";
+import { DEFAULT_SCHEMA_KEY, fetchSchemas, resolveSchemaPath } from "../spec/fetch.js";
+import { parseCedarSchema } from "../spec/parse.js";
+import { assertPinnedLangVersion, assertPinnedSchema } from "../spec/pin.js";
+/** Filename of the generated registry. */
+export const LEXICON_JSON_FILENAME = "lexicon-cedar.json";
+/** This package's root. `<pkg>/src/codegen/generate.ts` is three levels down. */
+export function packageDir() {
+    return dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+}
+function samePath(a, b) {
+    const real = (p) => (existsSync(p) ? realpathSync(p) : resolve(p));
+    return real(a) === real(b);
+}
+/**
+ * Where generated artifacts go (#1696).
+ *
+ * Three cases, in order:
+ *
+ *   1. `cedar.outDir` is set: that directory, resolved against the project root.
+ *   2. The project root *is* this package (the monorepo checkout, `npm run
+ *      generate`, `chant dev check-lexicon`): `<pkg>/src/generated`, which
+ *      `src/index.ts` re-exports so the package's own surface stays whole.
+ *   3. Anything else is a consumer: `<project>/src/generated/cedar`.
+ *
+ * Case 2 is what the old code assumed everywhere. A consumer's project root
+ * and the installed package are different directories, and writing into the
+ * second means the output is gone after `npm ci`.
+ */
+export function resolveGeneratedDir(options = {}) {
+    const root = options.projectRoot ?? process.cwd();
+    const configured = options.config?.outDir;
+    if (configured)
+        return isAbsolute(configured) ? configured : resolve(root, configured);
+    const pkg = packageDir();
+    if (samePath(root, pkg))
+        return resolve(pkg, "src", "generated");
+    return resolve(root, CEDAR_DEFAULT_OUT_DIR);
+}
+/**
+ * Run the code generation pipeline.
+ */
+export async function generate(options = {}) {
+    // Refuse a grammar nobody chose before reading anything (#1390's rule).
+    assertPinnedLangVersion();
+    // The three emit callbacks each need the same model, and the pipeline hands
+    // them the results separately. Memoizing on the results array keeps one
+    // build per run without a mutable `let` whose assignment TypeScript cannot
+    // see happening inside a callback.
+    const models = new Map();
+    const modelFor = (results, naming) => {
+        const cached = models.get(results);
+        if (cached)
+            return cached;
+        const built = buildEmitModel(results, naming);
+        models.set(results, built);
+        return built;
+    };
+    const result = await generatePipeline({
+        fetchSchemas: () => fetchSchemas({ projectRoot: options.projectRoot, config: options.config }),
+        parseSchema: (typeName, data) => {
+            const { decls, resolved } = parseCedarSchema(data.toString("utf-8"));
+            // The content pin covers the schema this package ships, not a user's.
+            // Theirs is their input; its churn is theirs to own.
+            if (typeName === DEFAULT_SCHEMA_KEY) {
+                assertPinnedSchema(resolved, decls.map((d) => d.typeName).sort());
+            }
+            return decls;
+        },
+        createNaming: (results) => createNaming(results),
+        generateRegistry: (results, naming) => generateRegistry(modelFor(results, naming)),
+        generateTypes: (results, naming) => generateTypes(modelFor(results, naming)),
+        generateRuntimeIndex: (results, naming) => generateRuntimeIndex(modelFor(results, naming)),
+        generateExtraArtifacts: () => ({ "runtime.ts": RUNTIME_TS }),
+    }, options);
+    if (options.verbose) {
+        const source = resolveSchemaPath({ projectRoot: options.projectRoot, config: options.config });
+        console.error(`Generated ${result.resources} declaration(s) from ` +
+            `${source.isDefault ? "the bundled default schema" : source.path}`);
+    }
+    return result;
+}
+/** The files one generate run produces, keyed by filename. */
+export function generatedFiles(result) {
+    return {
+        [LEXICON_JSON_FILENAME]: result.lexiconJSON,
+        "index.d.ts": result.typesDTS,
+        "index.ts": result.indexTS,
+        ...(result.extraArtifacts ?? {}),
+    };
+}
+/**
+ * Write generated files into `outDir`. With no directory given, writes where
+ * {@link resolveGeneratedDir} says for the current working directory.
+ */
+export function writeGeneratedFiles(result, outDir) {
+    writeGeneratedArtifacts({
+        baseDir: outDir ?? resolveGeneratedDir(),
+        generatedSubdir: ".",
+        files: generatedFiles(result),
+    });
+}