@intentius/chant-lexicon-cedar 0.44.8 → 0.44.10

package/src/index.ts

@@ -54,6 +54,82 @@ export type { CedarGenerateOptions, CedarGenerateResult } from "./import/generat
 export { CedarTemplateParser, CedarTemplateGenerator } from "./import/adapter";
 export { detectTemplate } from "./detect";
 
+// AgentCore embedding (#1660) — the typed statement an
+// `AWS::BedrockAgentCore::Policy` carries on either arm of its Definition
+// union, and the EnforcementMode dial that stages the rollout. Same
+// no-dependency rule as the AVP seam above. See src/agentcore/embed.ts.
+export {
+  agentCoreStatement,
+  agentCorePolicyDefinition,
+  agentCorePolicyResource,
+  agentCorePolicySet,
+  agentCoreStagedPolicy,
+  agentCorePolicyName,
+  AGENTCORE_NAME_PATTERN,
+  AGENTCORE_STATEMENT_MIN,
+  AGENTCORE_STATEMENT_MAX,
+} from "./agentcore/embed";
+export type {
+  AgentCoreCedarDefinition,
+  AgentCoreEmbedOptions,
+  AgentCoreLanguageDefinition,
+  AgentCorePolicyDefinition,
+  AgentCorePolicyResource,
+  AgentCorePolicySource,
+  AgentCoreStagedPolicy,
+} from "./agentcore/embed";
+export {
+  AGENTCORE_ENFORCEMENT,
+  describeStage,
+  enforcementMode,
+  enforcementStage,
+  isEnforcing,
+} from "./agentcore/enforcement";
+export type { AgentCoreEnforcementMode, AgentCoreStage } from "./agentcore/enforcement";
+export { embeddedAgentCoreDefinitions, embeddedAgentCorePolicyStatements } from "./agentcore/scan";
+export type { EmbeddedAgentCoreDefinition, EmbeddedAgentCoreStatement } from "./agentcore/scan";
+
+// The dogwood temporal dialect (#1658) — typed temporal builders, the `.dw`
+// serializer leg, `.dwschema` event schemas. Pre-release; see ./dogwood.
+//
+// Namespaced rather than flattened: the temporal sub-language's builders are
+// named after its own grammar (`and`, `not`, `count`, `sum`, `str`, `field`,
+// `record`, `window`), and spilling those into the package root would collide
+// with a schema-generated entity class the moment someone declares one. The
+// three entity classes are re-exported flat because that is what a policy file
+// names.
+export * as dogwood from "./dogwood/index";
+export {
+  DOGWOOD_EVENT_SCHEMA_FILENAME,
+  DOGWOOD_EVENT_SCHEMA_TYPE,
+  DOGWOOD_MACRO_FILENAME,
+  DOGWOOD_MACRO_LIBRARY_TYPE,
+  DOGWOOD_POLICY_FILENAME,
+  DOGWOOD_POLICY_TYPE,
+  TemporalEventSchema,
+  TemporalMacroLibrary,
+  TemporalPolicy,
+} from "./dogwood/policy";
+export type { EventSchemaProps, MacroLibraryProps, TemporalPolicyProps } from "./dogwood/policy";
+export { DOGWOOD_UPSTREAM } from "./dogwood/upstream";
+
+// The replay Op composite and its typed step builders (#1661). Flat, like
+// fly's `flyDeploy`: an Op factory is what a project's `ops/*.op.ts` names,
+// and it carries no dependency on the temporal lexicon — see
+// ./dogwood/replay-op.ts for why the composite ships from cedar.
+export {
+  DEFAULT_REPLAY_REPORT_PATH,
+  PolicyReplayOp,
+  dogwoodReplayReportStep,
+  dogwoodReplayStep,
+} from "./dogwood/replay-op";
+export type {
+  DogwoodReplayReportStepOpts,
+  DogwoodReplayStepOpts,
+  PolicyReplayOpConfig,
+  PolicyReplayOpResources,
+} from "./dogwood/replay-op";
+
 // Lint rules
 export { rules as cedarLintRules } from "./lint/rules";
 

package/src/lint/audit-catalog.ts

@@ -127,4 +127,68 @@ export const cedarAuditCatalog: Record<string, RuleMeta> = {
     'Name the actions the grant needs (action == Action::"read", or action in [ … ]) so it does not widen as the schema gains actions.',
     { category: "security" },
   ),
+
+  // ── The dogwood dialect (DWD) ──────────────────────────────────
+  //
+  // A second id family under the same lexicon, declared on the serializer as
+  // `extraRulePrefixes` (#1349's mechanism, the way k8s owns ARGO and FLUX).
+  // Dogwood is a dialect of Cedar rather than a peer language — a `.dw` file
+  // stripped of Cedar semantics is meaningless — so its checks ship here, and
+  // its ids are their own family so a reader can tell which surface bit them.
+  DWDC010: auditRule(
+    "DWDC010",
+    "merge-worthy",
+    "guidance",
+    "Dogwood temporal predicate names an undeclared event kind",
+    "Declare the event kind in the emitted .dwschema, or correct the predicate to a kind the schema derives — upstream rejects the policy set otherwise.",
+    { category: "correctness" },
+  ),
+  DWDC011: auditRule(
+    "DWDC011",
+    "merge-worthy",
+    "guidance",
+    "Dogwood temporal window exceeds the event schema's max_window",
+    "Shorten the window, or raise max_window in the event schema. With no schema emitted the cap is upstream's 24h default.",
+    { category: "correctness" },
+  ),
+  DWDC012: auditRule(
+    "DWDC012",
+    "merge-worthy",
+    "guidance",
+    "Dogwood formerly/previous/since is missing its window",
+    "Give the operator a `within <n><s|m|h|d>` window — all three past-only operators require one. The typed builders take it as an argument.",
+    { category: "correctness" },
+  ),
+  DWDC013: auditRule(
+    "DWDC013",
+    "report-only",
+    "guidance",
+    "AgentCore policy embeds temporal text with no event schema emitted",
+    "Declare a TemporalEventSchema so the .dwschema ships with the policy, or record where the service schema is registered — AWS::BedrockAgentCore::Policy has no property to carry it, and until the engine has it every temporal predicate in the statement matches nothing.",
+    { category: "correctness" },
+  ),
+  DWDE010: auditRule(
+    "DWDE010",
+    "merge-worthy",
+    "guidance",
+    "Dogwood policy set fails `dogwood validate`",
+    "Fix what upstream's frontend names — a macro, a temporal type error, or a Cedar body the action schema rejects. If the finding is the advisory, install the dogwood binary (or set cedar.dogwood.binary) so full .dw validation can run at all; without it only the DWDC walls apply.",
+    { category: "correctness" },
+  ),
+  DWDE011: auditRule(
+    "DWDE011",
+    "merge-worthy",
+    "guidance",
+    "Cedar lowered from a dogwood policy set fails Cedar validation",
+    "Fix the entity type, action, or attribute Cedar's validator names in the lowered body — the temporal clauses became context slots, so everything the finding points at is ordinary Cedar the policy wrote.",
+    { category: "correctness" },
+  ),
+  DWDS010: auditRule(
+    "DWDS010",
+    "report-only",
+    "guidance",
+    "Dogwood event schema pins nothing, widening every temporal predicate",
+    "Pin a field to the deciding request (pin callerPrincipal: principalType(A) = principal), or record that cross-principal correlation is the intent — supplying any event schema opts out of upstream's default pin.",
+    { category: "security" },
+  ),
 };

package/src/lint/post-synth/dogwood-helpers.ts

@@ -0,0 +1,139 @@
+/**
+ * Turning a build's emitted files into `dogwood` CLI invocations (#1659).
+ *
+ * The DWDE checks both need the same thing: which of the emitted `.dw` files
+ * is a policy set, which is a macro library, which `.cedarschema` backs
+ * `--policy-schema`, and which `.dwschema` backs `--event-schema`. Planning
+ * that once here keeps the two checks from disagreeing about what they ran —
+ * DWDE010 validates a bundle and DWDE011 lowers the *same* bundle, and a
+ * finding from one that names different inputs than the other would be a
+ * puzzle rather than a report.
+ *
+ * Excluded from check auto-discovery by the "helper" filename filter.
+ */
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import { blankComments, dogwoodPolicyFiles, dogwoodSchemaFiles, type DogwoodArtifact } from "../../dogwood/scan";
+import type { DogwoodBundle } from "../../dogwood/cli";
+
+/** One planned invocation: the files, and the names to blame in a finding. */
+export interface PreparedBundle {
+  lexicon: string;
+  /** The `.dw` policy set filename. */
+  source: string;
+  /** The `.cedarschema` filename passed as `--policy-schema`. */
+  policySchemaSource: string;
+  /** The `.dwschema` filename passed as `--event-schema`, when one was emitted. */
+  eventSchemaSource?: string;
+  bundle: DogwoodBundle;
+}
+
+/** What the CLI-gated checks should do with this build. */
+export interface DogwoodRunPlan {
+  /** True when the build emitted a `.dw` policy set at all. */
+  hasPolicies: boolean;
+  /** Every invocation to make. Empty when {@link blocked} is set. */
+  bundles: PreparedBundle[];
+  /** Why nothing can be run, when policies exist but a required input does not. */
+  blocked?: string;
+  /** The lexicon the `.dw` output came from, for a finding that names no file. */
+  lexicon?: string;
+}
+
+/**
+ * A `.dw` file holding only `def` declarations is a macro library, not a
+ * policy set.
+ *
+ * By structure rather than by filename: the serializer's default is
+ * `macros.dw`, but `MacroLibraryProps.filename` overrides it, and `chant
+ * audit` runs over trees chant never wrote. A policy set is a file with a
+ * `permit` or `forbid` head in it — upstream's policy grammar has no third
+ * effect — and a set with inlined macros still has one.
+ */
+export function looksLikeMacroLibrary(text: string): boolean {
+  return !/\b(permit|forbid)\s*\(/.test(blankComments(text));
+}
+
+function byName(a: DogwoodArtifact, b: DogwoodArtifact): number {
+  return a.source.localeCompare(b.source);
+}
+
+/**
+ * The Cedar action schema the CLI needs, as text.
+ *
+ * `--policy-schema` reads a human-readable `.cedarschema`; a `.cedarschema.json`
+ * is not a substitute, so it is not offered as one. Sorted by filename so a
+ * build emitting several picks the same one on every run.
+ */
+function findPolicySchema(ctx: PostSynthContext): DogwoodArtifact | undefined {
+  const found: DogwoodArtifact[] = [];
+  for (const [lexicon, output] of ctx.outputs) {
+    if (typeof output === "string") continue;
+    for (const [source, text] of Object.entries(output.files ?? {})) {
+      if (typeof text !== "string") continue;
+      if (!source.endsWith(".cedarschema")) continue;
+      found.push({ lexicon, source, text });
+    }
+  }
+  return found.sort(byName)[0];
+}
+
+/**
+ * Plan every `dogwood` invocation this build calls for.
+ *
+ * One bundle per policy set per emitted event schema. A build with several
+ * `.dwschema` files means several services, and `--event-schema` takes exactly
+ * one file, so the set is run against each and every finding names the schema
+ * it was found under — the alternative is picking one silently and reporting
+ * against a schema the reader did not choose. Macro libraries do combine: a
+ * library is a sequence of `def`s, so several concatenate into the one file
+ * `--macros` accepts.
+ */
+export function planDogwoodRuns(ctx: PostSynthContext): DogwoodRunPlan {
+  const files = dogwoodPolicyFiles(ctx).sort(byName);
+  const policySets = files.filter((f) => !looksLikeMacroLibrary(f.text));
+  if (policySets.length === 0) return { hasPolicies: false, bundles: [] };
+
+  const lexicon = policySets[0].lexicon;
+  const libraries = files.filter((f) => looksLikeMacroLibrary(f.text));
+  const macros = libraries.length > 0 ? libraries.map((f) => f.text).join("\n") : undefined;
+
+  const policySchema = findPolicySchema(ctx);
+  if (!policySchema) {
+    return {
+      hasPolicies: true,
+      bundles: [],
+      lexicon,
+      blocked:
+        "no Cedar action schema (.cedarschema) was emitted beside them, and `dogwood validate` requires one via --policy-schema",
+    };
+  }
+
+  const eventSchemas = dogwoodSchemaFiles(ctx).sort(byName);
+  const bundles: PreparedBundle[] = [];
+
+  for (const set of policySets) {
+    for (const events of eventSchemas.length > 0 ? eventSchemas : [undefined]) {
+      bundles.push({
+        lexicon: set.lexicon,
+        source: set.source,
+        policySchemaSource: policySchema.source,
+        ...(events ? { eventSchemaSource: events.source } : {}),
+        bundle: {
+          policies: set.text,
+          policySchema: policySchema.text,
+          ...(events ? { eventSchema: events.text } : {}),
+          ...(macros !== undefined ? { macros } : {}),
+        },
+      });
+    }
+  }
+
+  return { hasPolicies: true, bundles, lexicon };
+}
+
+/** How a finding names the inputs a run was made with. */
+export function describeBundle(prepared: PreparedBundle): string {
+  const parts = [`"${prepared.source}"`, `against "${prepared.policySchemaSource}"`];
+  if (prepared.eventSchemaSource) parts.push(`with "${prepared.eventSchemaSource}"`);
+  return parts.join(" ");
+}

package/src/lint/post-synth/dwd-post-synth.test.ts

@@ -0,0 +1,374 @@
+/**
+ * The DWD walls.
+ *
+ * Each check reads the emitted text, so every case here is built as a
+ * `PostSynthContext` holding files rather than by driving the serializer —
+ * that is the same shape `chant audit` hands them when it runs over a
+ * checked-in `.dw` chant never wrote.
+ */
+import { describe, test, expect } from "vitest";
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import { postSynthChecks } from "./index";
+import { dwdc010 } from "./dwdc010";
+import { dwdc011 } from "./dwdc011";
+import { dwdc012 } from "./dwdc012";
+import { dwdc013 } from "./dwdc013";
+import { dwds010 } from "./dwds010";
+import { cedarAuditCatalog } from "../audit-catalog";
+import { renderEventSchema, defaultEventSchema } from "../../dogwood/event-schema";
+import { blankComments, temporalRegions } from "../../dogwood/scan";
+
+function ctxOf(files: Record<string, string>): PostSynthContext {
+  const output: SerializerResult = { primary: "", files };
+  const outputs = new Map<string, string | SerializerResult>([["cedar", output]]);
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: { outputs, entities: new Map(), warnings: [], errors: [], sourceFileCount: 1 },
+  };
+}
+
+const PINNED = renderEventSchema(defaultEventSchema());
+
+function policy(body: string): string {
+  return `@id("p")\npermit (\n  principal,\n  action == Ns::Action::"Read",\n  resource\n)\nwhen temporal {\n    ${body}\n}\n;\n`;
+}
+
+// ── DWDC010 ────────────────────────────────────────────────────────
+
+describe("DWDC010 — the event kind must be declared", () => {
+  test("a declared kind passes", () => {
+    const ctx = ctxOf({
+      "policies.dw": policy('formerly within 1h Ns::Action::"Login"::response{}'),
+      "events.dwschema": PINNED,
+    });
+    expect(dwdc010.check(ctx)).toEqual([]);
+  });
+
+  test("an undeclared kind is an error naming both the predicate and the declared set", () => {
+    const ctx = ctxOf({
+      "policies.dw": policy('formerly within 1h Ns::Action::"Login"::nosuchkind{}'),
+      "events.dwschema": PINNED,
+    });
+    const [finding, ...rest] = dwdc010.check(ctx);
+    expect(rest).toEqual([]);
+    expect(finding.severity).toBe("error");
+    expect(finding.message).toContain('Ns::Action::"Login"::nosuchkind');
+    expect(finding.message).toContain("error, request, response");
+    expect(finding.entity).toBe("policies.dw");
+  });
+
+  test("author-defined kinds pass against the schema that declares them", () => {
+    const custom = "decision event <A>::attempt {\n    ...inputs(A),\n}\n";
+    const ctx = ctxOf({
+      "policies.dw": policy('formerly within 1h Ns::Action::"Login"::attempt{}'),
+      "events.dwschema": custom,
+    });
+    expect(dwdc010.check(ctx)).toEqual([]);
+  });
+
+  test("silent when no schema was emitted — the far end's defaults decide", () => {
+    const ctx = ctxOf({ "policies.dw": policy('formerly within 1h Ns::Action::"Login"::nosuchkind{}') });
+    expect(dwdc010.check(ctx)).toEqual([]);
+  });
+
+  test("a commented-out predicate is not a finding", () => {
+    const ctx = ctxOf({
+      "policies.dw": `// formerly within 1h Ns::Action::"Login"::nosuchkind{}\n${policy('formerly within 1h Ns::Action::"Login"::request{}')}`,
+      "events.dwschema": PINNED,
+    });
+    expect(dwdc010.check(ctx)).toEqual([]);
+  });
+
+  test("a Cedar when clause is not temporal source, so it is not scanned", () => {
+    const cedarOnly = `@id("p")\npermit (\n  principal,\n  action,\n  resource\n)\nwhen { context.kind == "nosuchkind" };\n`;
+    const ctx = ctxOf({ "policies.dw": cedarOnly, "events.dwschema": PINNED });
+    expect(dwdc010.check(ctx)).toEqual([]);
+  });
+
+  test("the same predicate twice is reported once", () => {
+    const body = 'formerly within 1h Ns::Action::"Login"::bogus{} && previous within 1h Ns::Action::"Login"::bogus{}';
+    const ctx = ctxOf({ "policies.dw": policy(body), "events.dwschema": PINNED });
+    expect(dwdc010.check(ctx)).toHaveLength(1);
+  });
+});
+
+// ── DWDC011 ────────────────────────────────────────────────────────
+
+describe("DWDC011 — the window must fit inside max_window", () => {
+  test("a window inside the default 24h cap passes with no schema emitted", () => {
+    const ctx = ctxOf({ "policies.dw": policy('formerly within 1h Ns::Action::"Login"::request{}') });
+    expect(dwdc011.check(ctx)).toEqual([]);
+  });
+
+  test("48h under the default 24h cap is an error even with no schema", () => {
+    const ctx = ctxOf({ "policies.dw": policy('formerly within 48h Ns::Action::"Login"::request{}') });
+    const [finding] = dwdc011.check(ctx);
+    expect(finding.severity).toBe("error");
+    expect(finding.message).toContain("looks back 48h");
+    expect(finding.message).toContain("24h");
+    expect(finding.message).toContain("no event schema was emitted");
+  });
+
+  test("raising max_window in the schema licenses the longer window", () => {
+    const raised = `max_window = 30d\n\n${PINNED.split("\n").slice(3).join("\n")}`;
+    const ctx = ctxOf({
+      "policies.dw": policy('formerly within 7d Ns::Action::"Login"::request{}'),
+      "events.dwschema": raised,
+    });
+    expect(dwdc011.check(ctx)).toEqual([]);
+  });
+
+  test("an emitted schema with no directive still caps at 24h", () => {
+    const ctx = ctxOf({
+      "policies.dw": policy('formerly within 25h Ns::Action::"Login"::request{}'),
+      "events.dwschema": PINNED,
+    });
+    expect(dwdc011.check(ctx)).toHaveLength(1);
+  });
+
+  test("the tightest of several schemas wins", () => {
+    const raised = `max_window = 30d\n\n${PINNED.split("\n").slice(3).join("\n")}`;
+    const ctx = ctxOf({
+      "policies.dw": policy('formerly within 7d Ns::Action::"Login"::request{}'),
+      "events.dwschema": raised,
+      "gateway.dwschema": PINNED,
+    });
+    expect(dwdc011.check(ctx)).toHaveLength(1);
+  });
+
+  test("a macro-call interval counts — it is the window the body resolves to", () => {
+    const ctx = ctxOf({ "policies.dw": policy('once(48h, Ns::Action::"Login"::request{})') });
+    const [finding] = dwdc011.check(ctx);
+    expect(finding.message).toContain("looks back 48h");
+  });
+
+  test("a window inside a macro definition is scanned too", () => {
+    const dw = `def temporal wide(?s) {\n    formerly within 72h ?s\n};\n\n${policy('wide(Ns::Action::"Login"::request{})')}`;
+    const ctx = ctxOf({ "policies.dw": dw });
+    expect(dwdc011.check(ctx)).toHaveLength(1);
+  });
+
+  test("no policy file means nothing to judge", () => {
+    expect(dwdc011.check(ctxOf({ "events.dwschema": PINNED }))).toEqual([]);
+  });
+});
+
+// ── DWDC012 ────────────────────────────────────────────────────────
+
+describe("DWDC012 — the window is not optional", () => {
+  test("a windowed operator passes", () => {
+    const ctx = ctxOf({ "policies.dw": policy('formerly within 1h Ns::Action::"Login"::request{}') });
+    expect(dwdc012.check(ctx)).toEqual([]);
+  });
+
+  test("a bare formerly is an error", () => {
+    const ctx = ctxOf({ "policies.dw": policy('formerly Ns::Action::"Login"::request{}') });
+    const [finding] = dwdc012.check(ctx);
+    expect(finding.severity).toBe("error");
+    expect(finding.message).toContain("`formerly` with no `within` window");
+  });
+
+  test("previous and since are held to the same rule", () => {
+    for (const operator of ["previous", "since"]) {
+      const ctx = ctxOf({ "policies.dw": policy(`${operator} Ns::Action::"Login"::request{}`) });
+      expect(dwdc012.check(ctx)[0]?.message).toContain(`\`${operator}\``);
+    }
+  });
+
+  test("a `within ?w` in a macro body is a window", () => {
+    const dw = `def temporal once(?w, ?s) {\n    formerly within ?w ?s\n};\n`;
+    expect(dwdc012.check(ctxOf({ "policies.dw": dw }))).toEqual([]);
+  });
+
+  test("a Cedar attribute named `since` outside a temporal block is not the operator", () => {
+    const cedarOnly = `@id("p")\npermit (\n  principal,\n  action,\n  resource\n)\nwhen { context.since > 3 };\n`;
+    expect(dwdc012.check(ctxOf({ "policies.dw": cedarOnly }))).toEqual([]);
+  });
+});
+
+// ── DWDS010 ────────────────────────────────────────────────────────
+
+describe("DWDS010 — an unpinned schema widens every predicate", () => {
+  test("the default shape's pin satisfies it", () => {
+    expect(dwds010.check(ctxOf({ "events.dwschema": PINNED }))).toEqual([]);
+  });
+
+  test("a schema with no pin is a report-only warning", () => {
+    const unpinned = renderEventSchema(defaultEventSchema({ pinCallerPrincipal: false }));
+    const [finding] = dwds010.check(ctxOf({ "events.dwschema": unpinned }));
+    expect(finding.severity).toBe("warning");
+    expect(finding.message).toContain("declares no pinned field");
+    expect(finding.entity).toBe("events.dwschema");
+  });
+
+  test("a file with no declarations at all is not the pin's problem", () => {
+    expect(dwds010.check(ctxOf({ "events.dwschema": "// nothing here\n" }))).toEqual([]);
+  });
+});
+
+// ── DWDC013 ────────────────────────────────────────────────────────
+
+/**
+ * A build with two lexicons in it: the cedar one, and whatever emitted the
+ * CloudFormation the AgentCore policy landed in. The check reads the emitted
+ * JSON rather than an aws entity class, which is what lets the cedar lexicon
+ * have an opinion about an embedding without depending on the aws lexicon.
+ */
+function ctxOfLexicons(byLexicon: Record<string, Record<string, string>>): PostSynthContext {
+  const outputs = new Map<string, string | SerializerResult>();
+  for (const [lexicon, files] of Object.entries(byLexicon)) {
+    outputs.set(lexicon, { primary: "", files } satisfies SerializerResult);
+  }
+  return {
+    outputs,
+    entities: new Map(),
+    buildResult: { outputs, entities: new Map(), warnings: [], errors: [], sourceFileCount: 1 },
+  };
+}
+
+const TEMPORAL_STATEMENT =
+  '@id("write-needs-approval")\npermit (\n  principal,\n  action == Ns::Action::"Write",\n  resource\n)\nwhen temporal {\n    formerly within 1h Ns::Action::"Approve"::response{}\n}\n;';
+
+const PLAIN_STATEMENT = '@id("deny")\nforbid (\n  principal,\n  action,\n  resource\n)\nunless { context.ok == true };';
+
+function template(definition: Record<string, unknown>, logicalId = "GatewayPolicy"): string {
+  return JSON.stringify({
+    Resources: {
+      [logicalId]: {
+        Type: "AWS::BedrockAgentCore::Policy",
+        Properties: {
+          PolicyEngineId: "GatewayEngine-abcdefghij",
+          Name: logicalId,
+          Definition: definition,
+          EnforcementMode: "LOG_ONLY",
+        },
+      },
+    },
+  });
+}
+
+describe("DWDC013 — an embedded temporal statement needs its event schema", () => {
+  test("temporal text with no emitted schema is a warning naming the resource", () => {
+    const ctx = ctxOfLexicons({
+      cedar: { "policies.dw": policy('formerly within 1h Ns::Action::"Approve"::response{}') },
+      aws: { "template.json": template({ Policy: { Statement: TEMPORAL_STATEMENT } }) },
+    });
+
+    const [finding, ...rest] = dwdc013.check(ctx);
+    expect(rest).toEqual([]);
+    expect(finding.severity).toBe("warning");
+    expect(finding.entity).toBe("GatewayPolicy");
+    expect(finding.lexicon).toBe("aws");
+    expect(finding.message).toContain("Definition.Policy.Statement");
+    expect(finding.message).toContain("no .dwschema");
+  });
+
+  test("an emitted event schema settles it", () => {
+    const ctx = ctxOfLexicons({
+      cedar: { "events.dwschema": PINNED },
+      aws: { "template.json": template({ Policy: { Statement: TEMPORAL_STATEMENT } }) },
+    });
+    expect(dwdc013.check(ctx)).toEqual([]);
+  });
+
+  test("plain Cedar in the language-agnostic arm is not this check's business", () => {
+    const ctx = ctxOfLexicons({
+      aws: { "template.json": template({ Policy: { Statement: PLAIN_STATEMENT } }) },
+    });
+    expect(dwdc013.check(ctx)).toEqual([]);
+  });
+
+  test("the Cedar arm is left alone — a temporal statement there is a different bug", () => {
+    const ctx = ctxOfLexicons({
+      aws: { "template.json": template({ Cedar: { Statement: TEMPORAL_STATEMENT } }) },
+    });
+    expect(dwdc013.check(ctx)).toEqual([]);
+  });
+
+  test("every embedded policy is reported, not only the first", () => {
+    const both = JSON.stringify({
+      Resources: {
+        Approval: {
+          Type: "AWS::BedrockAgentCore::Policy",
+          Properties: { Definition: { Policy: { Statement: TEMPORAL_STATEMENT } } },
+        },
+        Budget: {
+          Type: "AWS::BedrockAgentCore::Policy",
+          Properties: { Definition: { Policy: { Statement: TEMPORAL_STATEMENT } } },
+        },
+      },
+    });
+    const findings = dwdc013.check(ctxOfLexicons({ aws: { "template.json": both } }));
+    expect(findings.map((f) => f.entity).sort()).toEqual(["Approval", "Budget"]);
+  });
+
+  test("a build with no embedding at all is silent", () => {
+    const ctx = ctxOfLexicons({
+      cedar: { "policies.dw": policy('formerly within 1h Ns::Action::"Approve"::response{}') },
+    });
+    expect(dwdc013.check(ctx)).toEqual([]);
+  });
+
+  test("non-JSON output is skipped rather than reported", () => {
+    const ctx = ctxOfLexicons({ aws: { "template.yaml": "Resources:\n  Gateway:\n    Type: Whatever\n" } });
+    expect(dwdc013.check(ctx)).toEqual([]);
+  });
+});
+
+// ── Registration ───────────────────────────────────────────────────
+
+describe("registration", () => {
+  test("every DWD check is auto-discovered into the committed barrel", () => {
+    const ids = postSynthChecks.map((c) => c.id).filter((id) => id.startsWith("DWD"));
+    expect(ids.sort()).toEqual([
+      "DWDC010",
+      "DWDC011",
+      "DWDC012",
+      "DWDC013",
+      "DWDE010",
+      "DWDE011",
+      "DWDS010",
+    ]);
+  });
+
+  test("every DWD check has a catalog entry, so `chant audit` can title it", () => {
+    for (const check of postSynthChecks) {
+      if (!check.id.startsWith("DWD")) continue;
+      const meta = cedarAuditCatalog[check.id];
+      expect(meta, `${check.id} is catalogued`).toBeDefined();
+      expect(meta.title.length).toBeGreaterThan(0);
+      expect(meta.remediation.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("the catalog carries no DWD entry without a check behind it", () => {
+    const shipped = new Set(postSynthChecks.map((c) => c.id));
+    const stale = Object.keys(cedarAuditCatalog).filter((id) => id.startsWith("DWD") && !shipped.has(id));
+    expect(stale).toEqual([]);
+  });
+});
+
+// ── The scanner itself ─────────────────────────────────────────────
+
+describe("the text scanner", () => {
+  test("a // inside a string literal is not a comment", () => {
+    const text = 'when temporal { Ns::Action::"a//b"::request{} }';
+    expect(blankComments(text)).toBe(text);
+  });
+
+  test("a comment is blanked without moving any offset", () => {
+    const text = 'x // hidden\ny';
+    const blanked = blankComments(text);
+    expect(blanked).toHaveLength(text.length);
+    expect(blanked).toBe("x          \ny");
+  });
+
+  test("a temporal block is extracted through its nested braces", () => {
+    const text = 'when temporal { formerly within 1h Ns::Action::"A"::request{ input.x: 1 } }';
+    expect(temporalRegions(text)).toEqual([
+      ' formerly within 1h Ns::Action::"A"::request{ input.x: 1 } ',
+    ]);
+  });
+});