@intentius/chant-lexicon-cedar 0.124.30 → 0.124.32

package/dist/dogwood/window.js

@@ -0,0 +1,82 @@
+/**
+ * Temporal windows — the one thing dogwood's past-only operators cannot omit.
+ *
+ * `formerly`, `previous` and `since` all take a mandatory `within <n><unit>`
+ * clause; the unit is one of `s`, `m`, `h`, `d` and nothing else. Upstream's
+ * `temporal/grammar.pest` spells that out:
+ *
+ * ```
+ * within         = { "within" ~ within_payload }
+ * within_payload = { param_ref | (integer ~ time_unit) }
+ * time_unit      = { "s" | "m" | "h" | "d" }
+ * ```
+ *
+ * Typing the window as a value rather than as free text is what makes
+ * "a `formerly` without a window" unrepresentable in the builders (#1658's
+ * third lint wall) — you cannot call {@link formerly} without one.
+ *
+ * The `param_ref` arm (`within ?w`) is legal only inside a macro body; it is
+ * modelled by {@link MacroWindow} rather than by this type, so an ordinary
+ * policy cannot accidentally emit a sigil the expander would reject.
+ */
+const WINDOW_TEXT = /^(\d+)([smhd])$/;
+const PARAM_TEXT = /^\?[A-Za-z_][A-Za-z0-9_]*$/;
+/** True when the payload is `?w` rather than `1h`. */
+export function isWindowParam(value) {
+    return "param" in value;
+}
+/**
+ * `within ?w` inside a macro body.
+ *
+ * Exported from `./macros.ts` too, which is where the sigil rules are
+ * documented and where a reader looking for it will be.
+ */
+export function windowParam(param) {
+    if (!PARAM_TEXT.test(param)) {
+        throw new Error(`dogwood: a window parameter carries the "?" sigil — got "${param}"`);
+    }
+    return { param };
+}
+/** Seconds in one of each unit — the scale `max_window` comparisons run on. */
+const UNIT_SECONDS = { s: 1, m: 60, h: 3600, d: 86400 };
+/** Narrow a {@link WindowLike} to the structured form, validating as it goes. */
+export function window(value) {
+    if (typeof value !== "string") {
+        if (!Number.isInteger(value.value) || value.value < 0) {
+            throw new Error(`dogwood: a temporal window must be a non-negative integer, got ${String(value.value)}`);
+        }
+        if (!(value.unit in UNIT_SECONDS)) {
+            throw new Error(`dogwood: a temporal window unit must be s, m, h or d, got "${String(value.unit)}"`);
+        }
+        return { value: value.value, unit: value.unit };
+    }
+    const match = WINDOW_TEXT.exec(value);
+    if (!match) {
+        throw new Error(`dogwood: "${value}" is not a temporal window — write an integer and one of s, m, h, d (for example "1h")`);
+    }
+    return { value: Number(match[1]), unit: match[2] };
+}
+/** `1h` — the surface form, in a `within` clause or as a macro-call argument. */
+export function renderWindow(value) {
+    const w = window(value);
+    return `${w.value}${w.unit}`;
+}
+/** A `within` payload: `1h`, or the `?w` a macro body defers to its call site. */
+export function renderWindowValue(value) {
+    return isWindowParam(value) ? value.param : renderWindow(value);
+}
+/** Narrow a window argument, letting a `?w` parameter through unchanged. */
+export function windowValue(value) {
+    return typeof value === "object" && "param" in value ? windowParam(value.param) : window(value);
+}
+/** The window in seconds, so `90m` and `1h` are comparable to a `max_window`. */
+export function windowSeconds(value) {
+    const w = window(value);
+    return w.value * UNIT_SECONDS[w.unit];
+}
+/**
+ * Upstream's fallback cap. `ServiceSchema::defaults()` and an event schema
+ * with no `max_window` directive both look back at most 24 hours, per the
+ * comment atop `event_schema/grammar.pest` ("absent → a 24h default").
+ */
+export const DEFAULT_MAX_WINDOW = { value: 24, unit: "h" };

package/dist/gate-policy-pack.js

@@ -0,0 +1,189 @@
+/**
+ * A starter policy pack for gates (chant#3182): rules a platform team writes
+ * once and puts on every gate, the way Sentinel or OPA policies run against a
+ * Terraform plan. Each builder returns one cedar `Policy` over the plan
+ * summary core puts in `context.plan` (`GatePlanSummary`, declared by
+ * `GATE_CEDAR_SCHEMA`), so an Op needs no context code of its own.
+ *
+ * ```ts
+ * import { gatePolicy, protectStateful, capDeletes, permitLowRiskAgents } from "@intentius/chant-lexicon-cedar";
+ *
+ * export const prodGate = gatePolicy("prod", [
+ *   protectStateful(),
+ *   capDeletes({ max: 5 }),
+ *   permitLowRiskAgents({ maxChanges: 10 }),
+ * ]);
+ *
+ * gate("approve-prod", { plan: plan.out.planDigest, approval: { policy: prodGate, mode: "log-only" } });
+ * ```
+ *
+ * How the rules combine is Cedar's: a `forbid` beats every `permit`, and with
+ * no permit the answer is deny. The pack's forbids are the limits and its
+ * permits say when an agent may pass a gate on its own. A gate's quorum is
+ * unchanged by any of it, since a deny never removes a human's approval
+ * (`tallyGateApprovals`), and in `log-only` mode, the default, every decision
+ * is recorded and none binds, so a team can watch a rule against real plans
+ * before switching the gate to `enforce`.
+ *
+ * Every forbid fails closed: on a gate whose context has no `plan` (no change
+ * set behind the gate's `plan`), it applies. A limit nobody can check is not
+ * a reason to let an agent through.
+ */
+import { Policy } from "./generated/index.js";
+import { escapeCedarString } from "./policy-text.js";
+import { GATE_AGENT_TYPE, PASS_GATE_ACTION } from "./gate-policy.js";
+/**
+ * Resource types whose delete or replacement loses data: databases, buckets,
+ * volumes, queues with retention, and keys. Terraform-provider type names
+ * and the CloudFormation names the aws lexicon plans with.
+ */
+export const STATEFUL_TYPES = [
+    // AWS, terraform
+    "aws_db_instance", "aws_rds_cluster", "aws_rds_cluster_instance", "aws_rds_global_cluster",
+    "aws_dynamodb_table", "aws_dynamodb_global_table", "aws_s3_bucket", "aws_efs_file_system",
+    "aws_ebs_volume", "aws_elasticache_cluster", "aws_elasticache_replication_group",
+    "aws_docdb_cluster", "aws_neptune_cluster", "aws_redshift_cluster", "aws_opensearch_domain",
+    "aws_elasticsearch_domain", "aws_msk_cluster", "aws_kinesis_stream", "aws_sqs_queue",
+    "aws_kms_key", "aws_secretsmanager_secret", "aws_backup_vault", "aws_fsx_lustre_file_system",
+    // AWS, CloudFormation
+    "AWS::RDS::DBInstance", "AWS::RDS::DBCluster", "AWS::RDS::GlobalCluster", "AWS::DynamoDB::Table",
+    "AWS::DynamoDB::GlobalTable", "AWS::S3::Bucket", "AWS::EFS::FileSystem", "AWS::EC2::Volume",
+    "AWS::ElastiCache::CacheCluster", "AWS::ElastiCache::ReplicationGroup", "AWS::DocDB::DBCluster",
+    "AWS::Neptune::DBCluster", "AWS::Redshift::Cluster", "AWS::OpenSearchService::Domain",
+    "AWS::MSK::Cluster", "AWS::Kinesis::Stream", "AWS::SQS::Queue", "AWS::KMS::Key",
+    "AWS::SecretsManager::Secret", "AWS::Backup::BackupVault",
+    // Google Cloud
+    "google_sql_database_instance", "google_sql_database", "google_storage_bucket",
+    "google_bigquery_dataset", "google_bigquery_table", "google_spanner_instance",
+    "google_spanner_database", "google_compute_disk", "google_filestore_instance",
+    "google_redis_instance", "google_kms_crypto_key", "google_bigtable_instance",
+    // Azure
+    "azurerm_mssql_server", "azurerm_mssql_database", "azurerm_postgresql_flexible_server",
+    "azurerm_mysql_flexible_server", "azurerm_storage_account", "azurerm_cosmosdb_account",
+    "azurerm_managed_disk", "azurerm_redis_cache", "azurerm_key_vault",
+];
+// The generated scope types are narrowed to the project's own schema; these
+// names are the gate schema's (`GATE_CEDAR_SCHEMA`).
+const AGENT = GATE_AGENT_TYPE;
+const PASS_GATE = PASS_GATE_ACTION;
+const set = (values) => `[${values.map((v) => `"${escapeCedarString(v)}"`).join(", ")}]`;
+function count(name, value, fallback) {
+    const n = value ?? fallback;
+    if (!Number.isInteger(n) || n < 0)
+        throw new Error(`${name} must be a whole number of at least 0, got ${n}`);
+    return n;
+}
+function nonEmpty(name, values) {
+    if (!values || values.length === 0 || values.some((v) => typeof v !== "string" || v === "")) {
+        throw new Error(`${name} needs at least one non-empty name`);
+    }
+    return values;
+}
+function principal(appliesTo, fallback) {
+    return (appliesTo ?? fallback) === "agents" ? { is: AGENT } : {};
+}
+/** A forbid on `PassGate` that applies when there is no plan summary, or when `condition` holds. `condition` reads `context.plan`. */
+function forbid(id, appliesTo, condition, description) {
+    return new Policy({
+        effect: "forbid",
+        principal: principal(appliesTo, "everyone"),
+        action: { eq: PASS_GATE },
+        // Written as `unless`, so the validator sees `context has plan` guard the
+        // read of it (it tracks a `has` through `&&`): the forbid applies unless
+        // there is a plan and the condition does not hold.
+        unless: [`context has plan && !(${condition})`],
+        annotations: { id, description },
+    });
+}
+/** Forbid a plan that deletes more than `max` resources. Default id `cap-deletes`. */
+export function capDeletes(options = {}) {
+    const max = count("capDeletes: max", options.max, 0);
+    return forbid(options.id ?? "cap-deletes", options.appliesTo, `context.plan.deletes > ${max}`, `A plan may delete at most ${max} resources.`);
+}
+/** Forbid a plan that replaces more than `max` resources. Default id `cap-replacements`. */
+export function capReplacements(options = {}) {
+    const max = count("capReplacements: max", options.max, 0);
+    return forbid(options.id ?? "cap-replacements", options.appliesTo, `context.plan.replaces > ${max}`, `A plan may replace at most ${max} resources.`);
+}
+/**
+ * Forbid a plan that deletes or replaces a resource of a stateful type: an
+ * RDS instance, a DynamoDB table, a bucket. Default id `protect-stateful`.
+ */
+export function protectStateful(options = {}) {
+    const types = set(nonEmpty("protectStateful: types", options.types ?? STATEFUL_TYPES));
+    const deletes = options.deletes ?? true;
+    const replacements = options.replacements ?? true;
+    if (!deletes && !replacements)
+        throw new Error("protectStateful: deletes and replacements are both off, so the rule forbids nothing");
+    const conditions = [
+        ...(deletes ? [`context.plan.deletedTypes.containsAny(${types})`] : []),
+        ...(replacements ? [`context.plan.replacedTypes.containsAny(${types})`] : []),
+    ];
+    return forbid(options.id ?? "protect-stateful", options.appliesTo, conditions.length === 1 ? conditions[0] : `(${conditions.join(" || ")})`, `A plan may not ${[deletes ? "delete" : "", replacements ? "replace" : ""].filter(Boolean).join(" or ")} a resource that holds state.`);
+}
+/** Forbid a plan that changes anything outside these regions. Default id `allow-regions`. */
+export function allowRegions(options) {
+    const regions = nonEmpty("allowRegions: regions", options.regions);
+    return forbid(options.id ?? "allow-regions", options.appliesTo, `!${set(regions)}.containsAll(context.plan.regions)`, `A plan may change resources only in ${regions.join(", ")}.`);
+}
+/**
+ * Forbid a plan whose tagged creates do not all carry `keys`. Reads
+ * `tags`, `tags_all` and `labels`. Default id `require-create-tags`.
+ */
+export function requireCreateTags(options) {
+    const keys = nonEmpty("requireCreateTags: keys", options.keys);
+    const missing = `(context.plan.taggedCreates > 0 && !context.plan.createTagKeys.containsAll(${set(keys)}))`;
+    return forbid(options.id ?? "require-create-tags", options.appliesTo, options.strict ? `(${missing} || context.plan.untaggedCreates > 0)` : missing, `Every created resource carries the tags ${keys.join(", ")}.`);
+}
+/**
+ * Permit an agent to pass a gate on its own for a plan that deletes and
+ * replaces nothing, changes at most `maxChanges` resources, and planned
+ * every member in full (no failed member, no hole). In `enforce` mode that
+ * permit passes the gate; any forbid in the same set still wins.
+ */
+export function permitLowRiskAgents(options = {}) {
+    const max = count("permitLowRiskAgents: maxChanges", options.maxChanges, 10);
+    return new Policy({
+        effect: "permit",
+        principal: { is: AGENT },
+        action: { eq: PASS_GATE },
+        when: [
+            "context has plan && " +
+                `context.plan.deletes == 0 && context.plan.replaces == 0 && context.plan.changes <= ${max} && ` +
+                "context.plan.failed == 0 && context.plan.holes == 0",
+        ],
+        annotations: {
+            id: options.id ?? "permit-low-risk-agents",
+            description: `An agent may pass a plan that deletes and replaces nothing and changes at most ${max} resources.`,
+        },
+    });
+}
+/** Permit an agent to pass a plan that only changes tags or labels. Default id `permit-tag-only-agents`. */
+export function permitTagOnlyAgents(options = {}) {
+    return new Policy({
+        effect: "permit",
+        principal: { is: AGENT },
+        action: { eq: PASS_GATE },
+        when: ["context has plan && context.plan.tagOnly && context.plan.failed == 0 && context.plan.holes == 0"],
+        annotations: {
+            id: options.id ?? "permit-tag-only-agents",
+            description: "An agent may pass a plan that only changes tags or labels.",
+        },
+    });
+}
+/**
+ * The pack as one record for `gatePolicy(name, starterGatePolicies(...))`:
+ * stateful types protected, deletes capped, regions and tags when given,
+ * and the two agent permits.
+ */
+export function starterGatePolicies(options = {}) {
+    return {
+        protectStateful: protectStateful(options.statefulTypes ? { types: options.statefulTypes } : {}),
+        capDeletes: capDeletes({ max: options.maxDeletes ?? 0 }),
+        ...(options.maxReplacements !== undefined ? { capReplacements: capReplacements({ max: options.maxReplacements }) } : {}),
+        ...(options.regions ? { allowRegions: allowRegions({ regions: options.regions }) } : {}),
+        ...(options.requiredTags ? { requireCreateTags: requireCreateTags({ keys: options.requiredTags }) } : {}),
+        permitLowRiskAgents: permitLowRiskAgents(options.agentMaxChanges !== undefined ? { maxChanges: options.agentMaxChanges } : {}),
+        permitTagOnlyAgents: permitTagOnlyAgents(),
+    };
+}

package/dist/gate-policy.js

@@ -0,0 +1,168 @@
+/**
+ * Cedar as a gate's approval policy (chant#2508).
+ *
+ * Two halves, one per side of the build:
+ *
+ * - {@link gatePolicy} renders a set of cedar `Policy` declarables to Cedar
+ *   text at authoring time and returns core's `GatePolicyRef`, plain data that
+ *   lands in the Op's build output. A gate names it as `approval.policy`.
+ * - {@link evaluateGatePolicy} is what core's `loadGatePolicyEvaluator("cedar")`
+ *   imports from `@intentius/chant-lexicon-cedar/gate-policy`. `chant approve`
+ *   calls it once per approval with a `PassGate` request, through the same
+ *   `cedar-wasm` the post-synth checks load (`./lint/post-synth/wasm-helpers.ts`).
+ *
+ * The request uses these entity types, so a policy is written against them:
+ *
+ * | Position  | Entity                                   | Attributes / parents |
+ * |-----------|------------------------------------------|----------------------|
+ * | principal | `Chant::Human::"<name>"` or `Chant::Agent::"<name>"` | parents: one `Chant::Role::"<role>"` per claimed role |
+ * | action    | `Chant::Action::"PassGate"`              | |
+ * | resource  | `Chant::Gate::"<op>/<gate>"`             | `op`, `gate` |
+ * | context   | `planDigest` when the gate binds a plan, plus the gate's `approval.context` | |
+ *
+ * So `principal is Chant::Agent` picks out an agent, `principal in
+ * Chant::Role::"maintainer"` a role, and `context.risk == "low"` a declared
+ * plan attribute.
+ */
+import { gatePolicyVersion, } from "@intentius/chant/op";
+import { getProps, resolvePolicyId } from "./policy-text.js";
+import { CEDAR_POLICY_TYPE, renderPolicyText } from "./serializer.js";
+import { describeError, loadWasm, wasmLoadError } from "./lint/post-synth/wasm-helpers.js";
+export const GATE_HUMAN_TYPE = "Chant::Human";
+export const GATE_AGENT_TYPE = "Chant::Agent";
+export const GATE_ROLE_TYPE = "Chant::Role";
+export const GATE_RESOURCE_TYPE = "Chant::Gate";
+/** `action == Chant::Action::"PassGate"`, ready for a `Policy`'s `action` scope. */
+export const PASS_GATE_ACTION = 'Chant::Action::"PassGate"';
+function entries(name, policies) {
+    if (Array.isArray(policies)) {
+        return policies.map((p, i) => [`${name}-${i}`, p]);
+    }
+    if (isDeclarable(policies))
+        return [[name, policies]];
+    return Object.entries(policies);
+}
+function isDeclarable(value) {
+    return typeof value === "object" && value !== null && "entityType" in value;
+}
+/**
+ * A gate policy set from cedar `Policy` declarables. `name` is recorded with
+ * every decision; ids come from each policy's `annotations.id`, else its
+ * record key, else `<name>-<index>`.
+ *
+ * Throws when a member is not a cedar policy, or when the rendered set does
+ * not parse, so a broken policy fails where it is written and not at the
+ * first `chant approve`.
+ *
+ * @example
+ * ```ts
+ * export const shipPolicy = gatePolicy("ship", {
+ *   agentLowRisk: new Policy({
+ *     effect: "permit",
+ *     principal: { is: GATE_AGENT_TYPE },
+ *     action: { eq: PASS_GATE_ACTION },
+ *     when: ['context.risk == "low"'],
+ *   }),
+ * });
+ * ```
+ */
+export function gatePolicy(name, policies) {
+    const members = entries(name, policies);
+    if (members.length === 0)
+        throw new Error(`gatePolicy("${name}"): the policy set is empty`);
+    const texts = members.map(([logical, entity]) => {
+        if (entity.entityType !== CEDAR_POLICY_TYPE) {
+            throw new Error(`gatePolicy("${name}"): "${logical}" is a ${entity.entityType}, not a ${CEDAR_POLICY_TYPE}`);
+        }
+        const props = getProps(entity);
+        return renderPolicyText(resolvePolicyId(logical, props), props);
+    });
+    const text = texts.join("\n\n") + "\n";
+    const wasm = loadWasm();
+    if (wasm) {
+        const parsed = wasm.checkParsePolicySet({ staticPolicies: text });
+        if (parsed.type === "failure") {
+            throw new Error(`gatePolicy("${name}"): the policy set does not parse: ${parsed.errors.map(describeError).join("; ")}`);
+        }
+    }
+    return { kind: "gate-policy", lexicon: "cedar", name, version: gatePolicyVersion(text), text };
+}
+/** A context value as Cedar JSON. Cedar has no floats or null, so those become strings or are dropped. */
+function cedarValue(value) {
+    if (typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isInteger(value) ? value : String(value);
+    if (Array.isArray(value)) {
+        return value.map(cedarValue).filter((v) => v !== undefined);
+    }
+    if (typeof value === "object" && value !== null) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const converted = cedarValue(v);
+            if (converted !== undefined)
+                out[k] = converted;
+        }
+        return out;
+    }
+    return undefined;
+}
+/**
+ * The set as a record keyed by each policy's `@id`. Handed the text whole,
+ * cedar-wasm names policies by position (`policy0`), and a recorded decision
+ * would then name a rule nobody wrote. A policy with no `@id` keeps its
+ * positional name. Exported for `./gate-schema.ts`, so validation names rules the same way.
+ */
+export function keyedById(wasm, policy) {
+    const parts = wasm.policySetTextToParts(policy.text);
+    if (parts.type === "failure") {
+        throw new Error(`policy "${policy.name}" does not parse: ${parts.errors.map(describeError).join("; ")}`);
+    }
+    const keyed = {};
+    parts.policies.forEach((text, index) => {
+        const id = /@id\(\s*"((?:[^"\\]|\\.)*)"\s*\)/.exec(text)?.[1] ?? `policy${index}`;
+        if (id in keyed)
+            throw new Error(`policy "${policy.name}" has two policies with id "${id}"`);
+        keyed[id] = text;
+    });
+    return keyed;
+}
+/**
+ * Evaluate one `PassGate` request. Called by core through
+ * `loadGatePolicyEvaluator("cedar")`; see the module doc for the entity model.
+ *
+ * Throws when the wasm cannot be loaded or the request cannot be evaluated at
+ * all, so `chant approve` refuses rather than recording a decision nobody
+ * made. A policy that errors on this request is reported in `errors` and does
+ * not apply, which is Cedar's own rule.
+ */
+export function evaluateGatePolicy(policy, request) {
+    const wasm = loadWasm();
+    if (!wasm)
+        throw new Error(`@cedar-policy/cedar-wasm could not be loaded: ${wasmLoadError()}`);
+    const principalType = request.principal.kind === "agent" ? GATE_AGENT_TYPE : GATE_HUMAN_TYPE;
+    const roles = [...new Set(request.principal.roles)];
+    const principal = { type: principalType, id: request.principal.name };
+    const resource = { type: GATE_RESOURCE_TYPE, id: `${request.resource.op}/${request.resource.gate}` };
+    const answer = wasm.isAuthorized({
+        principal,
+        action: { type: "Chant::Action", id: request.action },
+        resource,
+        context: (cedarValue(request.context) ?? {}),
+        policies: { staticPolicies: keyedById(wasm, policy) },
+        entities: [
+            { uid: principal, attrs: {}, parents: roles.map((id) => ({ type: GATE_ROLE_TYPE, id })) },
+            ...roles.map((id) => ({ uid: { type: GATE_ROLE_TYPE, id }, attrs: {}, parents: [] })),
+            { uid: resource, attrs: { op: request.resource.op, gate: request.resource.gate }, parents: [] },
+        ],
+    });
+    if (answer.type === "failure") {
+        throw new Error(`policy "${policy.name}" could not be evaluated: ${answer.errors.map(describeError).join("; ")}`);
+    }
+    const { decision, diagnostics } = answer.response;
+    return {
+        decision,
+        determining: [...diagnostics.reason].sort(),
+        errors: diagnostics.errors.map((e) => `${e.policyId}: ${describeError(e.error)}`),
+    };
+}

package/dist/gate-schema.js

@@ -0,0 +1,122 @@
+/**
+ * The Cedar schema of a gate's `PassGate` request (chant#3182).
+ *
+ * {@link GATE_CEDAR_SCHEMA} declares the `Chant` namespace `evaluateGatePolicy`
+ * builds requests in (`./gate-policy.ts`), with the plan summary core puts in
+ * `context.plan` (`@intentius/chant/op`'s `GatePlanSummary`) as the common type
+ * `Chant::PlanSummary`. Two uses:
+ *
+ * - {@link validateGatePolicy} checks a gate policy set against it, so a rule
+ *   that reads `context.plan.deleteCount` (a field that does not exist) fails
+ *   where it is written rather than erroring on every request.
+ * - A project that writes gate policies with typed `Policy` scopes puts this
+ *   text in its own `.cedarschema` (or hands {@link gateCedarSchema}'s output
+ *   to `new Schema({ text })`), and the generated scope types then name
+ *   `Chant::Agent` and `Chant::Action::"PassGate"` without a cast.
+ *
+ * A gate's own `approval.context` keys differ per gate, so the schema declares
+ * only `planDigest` and `plan` unless {@link gateCedarSchema} is told the rest.
+ * Every context attribute is optional: a gate with no plan, or a plan step
+ * that returned no change set, has neither.
+ */
+import { loadWasm, validatePolicySet, wasmLoadError } from "./lint/post-synth/wasm-helpers.js";
+import { keyedById } from "./gate-policy.js";
+/**
+ * Each `GatePlanSummary` field as a Cedar type. Typed as a record over the
+ * summary's keys, so a field added to the summary in core fails to compile
+ * here until the schema says what it is.
+ */
+export const GATE_PLAN_SUMMARY_CEDAR_TYPES = {
+    members: "Set<String>",
+    membersChanged: "Set<String>",
+    failedMembers: "Set<String>",
+    failed: "Long",
+    holes: "Long",
+    entries: "Long",
+    changes: "Long",
+    creates: "Long",
+    updates: "Long",
+    replaces: "Long",
+    deletes: "Long",
+    reads: "Long",
+    noOps: "Long",
+    forgets: "Long",
+    types: "Set<String>",
+    createdTypes: "Set<String>",
+    updatedTypes: "Set<String>",
+    replacedTypes: "Set<String>",
+    deletedTypes: "Set<String>",
+    deleted: "Set<String>",
+    replaced: "Set<String>",
+    regions: "Set<String>",
+    scopes: "Set<String>",
+    lexicons: "Set<String>",
+    taggedCreates: "Long",
+    untaggedCreates: "Long",
+    createTagKeys: "Set<String>",
+    tagOnly: "Bool",
+    truncated: "Bool",
+};
+const IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** The schema text, with the gate's own context attributes when given. */
+export function gateCedarSchema(options = {}) {
+    const extra = Object.entries(options.context ?? {});
+    for (const [key, type] of extra) {
+        if (!IDENT.test(key))
+            throw new Error(`gateCedarSchema: context attribute "${key}" is not a Cedar identifier`);
+        if (key === "plan" || key === "planDigest")
+            throw new Error(`gateCedarSchema: context attribute "${key}" is chant's own`);
+        if (type.trim() === "")
+            throw new Error(`gateCedarSchema: context attribute "${key}" has no type`);
+    }
+    const summary = Object.entries(GATE_PLAN_SUMMARY_CEDAR_TYPES)
+        .map(([k, t]) => `    "${k}": ${t},`)
+        .join("\n");
+    const context = [
+        `      "planDigest"?: String,`,
+        `      "plan"?: PlanSummary,`,
+        ...extra.map(([k, t]) => `      "${k}"?: ${t},`),
+    ].join("\n");
+    return `// The request chant builds for a gate approval (chant#2508, #3182).
+namespace Chant {
+  // context.plan: the plan's change-set summary (GatePlanSummary).
+  type PlanSummary = {
+${summary}
+  };
+
+  // A role a human or agent claimed when approving.
+  entity Role;
+  entity Human in [Role];
+  entity Agent in [Role];
+  // "<op>/<gate>".
+  entity Gate = {
+    "op": String,
+    "gate": String,
+  };
+
+  action PassGate appliesTo {
+    principal: [Human, Agent],
+    resource: [Gate],
+    context: {
+${context}
+    }
+  };
+}
+`;
+}
+/** The schema with no gate-specific context: `planDigest` and `plan` only. */
+export const GATE_CEDAR_SCHEMA = gateCedarSchema();
+/**
+ * Validate a gate policy set against the gate schema. Throws when the wasm
+ * cannot be loaded or validation cannot run at all (a schema that does not
+ * parse); findings come back sorted.
+ */
+export function validateGatePolicy(policy, options = {}) {
+    const wasm = loadWasm();
+    if (!wasm)
+        throw new Error(`@cedar-policy/cedar-wasm could not be loaded: ${wasmLoadError()}`);
+    const outcome = validatePolicySet(wasm, { staticPolicies: keyedById(wasm, policy) }, gateCedarSchema(options));
+    if (outcome.failure)
+        throw new Error(`policy "${policy.name}" could not be validated: ${outcome.failure}`);
+    return { errors: outcome.errors, warnings: outcome.warnings };
+}

package/dist/generated/index.js

@@ -0,0 +1,94 @@
+import { createProperty, createResource } from "./runtime.js";
+/**
+ * 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 = createResource("Cedar::Policy", "cedar", {});
+export const Application = createResource("App::Application", "cedar", {});
+export const ApplicationAttributes = createProperty("App::Application.Attributes", "cedar");
+export const Document = createResource("App::Document", "cedar", {});
+export const DocumentAttributes = createProperty("App::Document.Attributes", "cedar");
+export const Folder = createResource("App::Folder", "cedar", {});
+export const FolderAttributes = createProperty("App::Folder.Attributes", "cedar");
+export const Group = createResource("App::Group", "cedar", {});
+export const GroupAttributes = createProperty("App::Group.Attributes", "cedar");
+export const ServiceAccount = createResource("App::ServiceAccount", "cedar", {});
+export const ServiceAccountAttributes = createProperty("App::ServiceAccount.Attributes", "cedar");
+export const Team = createResource("App::Team", "cedar", {});
+export const TeamAttributes = createProperty("App::Team.Attributes", "cedar");
+export const User = createResource("App::User", "cedar", {});
+export const UserAttributes = createProperty("App::User.Attributes", "cedar");
+/**
+ * `App::Action::"admin"`.
+ * Principals: App::User.
+ * Resources: App::Application.
+ */
+export const AdminAction = "App::Action::\"admin\"";
+export const AdminContext = createProperty("App::Action::\"admin\".Context", "cedar");
+/**
+ * `App::Action::"approve"`.
+ * Principals: App::User.
+ * Resources: App::Document.
+ */
+export const ApproveAction = "App::Action::\"approve\"";
+export const ApproveContext = createProperty("App::Action::\"approve\".Context", "cedar");
+/**
+ * `App::Action::"comment"`.
+ * Principals: App::User.
+ * Resources: App::Document, App::Folder.
+ */
+export const CommentAction = "App::Action::\"comment\"";
+export const CommentContext = createProperty("App::Action::\"comment\".Context", "cedar");
+/**
+ * `App::Action::"create"`.
+ * Principals: App::User.
+ * Resources: App::Document, App::Folder.
+ */
+export const CreateAction = "App::Action::\"create\"";
+export const CreateContext = createProperty("App::Action::\"create\".Context", "cedar");
+/**
+ * `App::Action::"delete"`.
+ * Principals: App::User.
+ * Resources: App::Document.
+ */
+export const DeleteAction = "App::Action::\"delete\"";
+export const DeleteContext = createProperty("App::Action::\"delete\".Context", "cedar");
+/**
+ * `App::Action::"list"`.
+ * Principals: App::ServiceAccount, App::User.
+ * Resources: App::Document, App::Folder.
+ */
+export const ListAction = "App::Action::\"list\"";
+export const ListContext = createProperty("App::Action::\"list\".Context", "cedar");
+/**
+ * `App::Action::"read"`.
+ * Principals: App::ServiceAccount, App::User.
+ * Resources: App::Document, App::Folder.
+ */
+export const ReadAction = "App::Action::\"read\"";
+export const ReadContext = createProperty("App::Action::\"read\".Context", "cedar");
+/**
+ * `App::Action::"share"`.
+ * Principals: App::User.
+ * Resources: App::Document.
+ */
+export const ShareAction = "App::Action::\"share\"";
+export const ShareContext = createProperty("App::Action::\"share\".Context", "cedar");
+/**
+ * `App::Action::"write"`.
+ * Principals: App::User.
+ * Resources: App::Document, App::Folder.
+ */
+export const WriteAction = "App::Action::\"write\"";
+export const WriteContext = createProperty("App::Action::\"write\".Context", "cedar");
+/** Every generated action constant, for exhaustive iteration. */
+export const ALL_ACTIONS = [AdminAction, ApproveAction, CommentAction, CreateAction, DeleteAction, ListAction, ReadAction, ShareAction, WriteAction];
+/** Every entity type name the schema declares. */
+export const ALL_ENTITY_TYPES = ["App::Application", "App::Document", "App::Folder", "App::Group", "App::ServiceAccount", "App::Team", "App::User"];

package/dist/generated/runtime.js

@@ -0,0 +1,2 @@
+// Code generated by chant generate. DO NOT EDIT.
+export { createProperty, createResource } from "@intentius/chant/runtime";