@intentius/chant-lexicon-cedar 0.44.8 → 0.44.9

package/dist/dogwood/policy.d.ts

@@ -0,0 +1,120 @@
+/**
+ * The dogwood entity model: a temporal policy, an event schema, a macro library.
+ *
+ * `Dogwood::TemporalPolicy` is `Cedar::Policy` plus the two clause forms
+ * upstream's policy grammar adds. Its head — annotations, effect, the three
+ * scope positions — is Cedar's, byte for byte, which is why `./serialize.ts`
+ * renders it with the cedar serializer's own `renderPolicyHead` rather than a
+ * copy of it. Only the `cond` rule differs:
+ *
+ * ```
+ * cond = { cond_kw ~ (extension_marker | guardrails_tag? ~ "{" ~ expr ~ "}") }
+ * ```
+ *
+ * — so a clause is `when { … }`, `when guardrails { … }`, or
+ * `when temporal { … }`, and the same three under `unless`. `guardrails` is
+ * transparent sugar for a bare Cedar expression (upstream discards the tag
+ * during lowering); `temporal { … }` is a genuine sub-language dispatched to a
+ * different parser.
+ *
+ * These are not schema-driven the way `Cedar::Policy`'s generated class is.
+ * Codegen's input is the project's `.cedarschema`, which says nothing about
+ * event kinds or temporal operators, so the dialect's classes are written here
+ * and typed against the builders in `./temporal.ts`.
+ */
+import type { Declarable } from "@intentius/chant/declarable";
+import type { CedarEffect, CedarScope } from "../serializer.js";
+import type { TemporalCondition } from "./temporal.js";
+import type { EventSchema } from "./event-schema.js";
+import type { MacroDefinition } from "./macros.js";
+/** The lexicon these entities belong to — dogwood is a dialect of cedar, not a lexicon. */
+export declare const DOGWOOD_LEXICON = "cedar";
+/** The `entityType` of a temporal policy. */
+export declare const DOGWOOD_POLICY_TYPE = "Dogwood::TemporalPolicy";
+/** The `entityType` of an event schema. */
+export declare const DOGWOOD_EVENT_SCHEMA_TYPE = "Dogwood::EventSchema";
+/** The `entityType` of a macro library. */
+export declare const DOGWOOD_MACRO_LIBRARY_TYPE = "Dogwood::MacroLibrary";
+/** The `.dw` policy set written beside the cedar outputs. */
+export declare const DOGWOOD_POLICY_FILENAME = "policies.dw";
+/** The `.dwschema` event schema — what `dogwood validate --event-schema` reads. */
+export declare const DOGWOOD_EVENT_SCHEMA_FILENAME = "events.dwschema";
+/** The macro library — what `dogwood validate --macros` reads. */
+export declare const DOGWOOD_MACRO_FILENAME = "macros.dw";
+/**
+ * The props of a `Dogwood::TemporalPolicy`.
+ *
+ * The first six mirror `CedarPolicyProps` exactly. The rest are the dialect's.
+ */
+export interface TemporalPolicyProps {
+    /** Defaults to `permit` when omitted. */
+    effect?: CedarEffect;
+    /** Defaults to unconstrained (`{}`) when omitted. */
+    principal?: CedarScope;
+    /** Defaults to unconstrained (`{}`) when omitted. */
+    action?: CedarScope;
+    /** Defaults to unconstrained (`{}`) when omitted. */
+    resource?: CedarScope;
+    /** 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>;
+    /** Each emitted as its own `when temporal { … }` clause. */
+    whenTemporal?: TemporalCondition[];
+    /** Each emitted as its own `unless temporal { … }` clause. */
+    unlessTemporal?: TemporalCondition[];
+    /**
+     * Cedar expression strings emitted as `when guardrails { … }`.
+     *
+     * The tag carries no separate grammar — upstream parses the body as an
+     * ordinary Cedar expression and discards the tag when lowering. It marks a
+     * clause as a guardrail for a human reader and for whatever reads the source
+     * after chant; it does not change what the policy means.
+     */
+    whenGuardrails?: string[];
+    /** As {@link whenGuardrails}, negated. */
+    unlessGuardrails?: string[];
+}
+/**
+ * A temporal policy. Declare one per policy, the same way as `Cedar::Policy`:
+ *
+ * ```ts
+ * export const readAfterLogin = new TemporalPolicy({
+ *   action: { eq: 'Drupe::Action::"Read"' },
+ *   whenTemporal: [
+ *     formerly("1h", predicate('Drupe::Action::"Login"', "response", {
+ *       "input.user": ctx("input.user"),
+ *     })),
+ *   ],
+ * });
+ * ```
+ */
+export declare const TemporalPolicy: new (props: TemporalPolicyProps) => Declarable;
+/** The props of a `Dogwood::EventSchema`. */
+export interface EventSchemaProps {
+    /** Built with `eventSchema()` or `defaultEventSchema()`. */
+    schema: EventSchema;
+    /** Defaults to {@link DOGWOOD_EVENT_SCHEMA_FILENAME}. */
+    filename?: string;
+}
+/** The service half of the schema, emitted as `.dwschema` text. */
+export declare const TemporalEventSchema: new (props: EventSchemaProps) => Declarable;
+/** The props of a `Dogwood::MacroLibrary`. */
+export interface MacroLibraryProps {
+    macros: MacroDefinition[];
+    /** Defaults to {@link DOGWOOD_MACRO_FILENAME}. Ignored when `inline` is set. */
+    filename?: string;
+    /**
+     * Emit the definitions at the top of the policy set instead of into their own
+     * file.
+     *
+     * A policy set's own `def` shadows a same-named library macro, so inlining is
+     * how a project stops depending on whoever runs the CLI passing `--macros`.
+     */
+    inline?: boolean;
+}
+/** A `def cedar` / `def temporal` library, emitted as `.dw` text. */
+export declare const TemporalMacroLibrary: new (props: MacroLibraryProps) => Declarable;
+//# sourceMappingURL=policy.d.ts.map

package/dist/dogwood/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/dogwood/policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,2FAA2F;AAC3F,eAAO,MAAM,eAAe,UAAU,CAAC;AAEvC,6CAA6C;AAC7C,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D,2CAA2C;AAC3C,eAAO,MAAM,yBAAyB,yBAAyB,CAAC;AAEhE,2CAA2C;AAC3C,eAAO,MAAM,0BAA0B,0BAA0B,CAAC;AAElE,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,gBAAgB,CAAC;AAErD,mFAAmF;AACnF,eAAO,MAAM,6BAA6B,oBAAoB,CAAC;AAE/D,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,cAAc,CAAC;AAElD;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,yCAAyC;IACzC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,qDAAqD;IACrD,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,qDAAqD;IACrD,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,6EAA6E;IAC7E,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAErC,4DAA4D;IAC5D,YAAY,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACnC,8DAA8D;IAC9D,cAAc,CAAC,EAAE,iBAAiB,EAAE,CAAC;IACrC;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,0CAA0C;IAC1C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,EAA0E,KACnG,KAAK,EAAE,mBAAmB,KACvB,UAAU,CAAC;AAEhB,6CAA6C;AAC7C,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,MAAM,EAAE,WAAW,CAAC;IACpB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,mEAAmE;AACnE,eAAO,MAAM,mBAAmB,EAAgF,KAC9G,KAAK,EAAE,gBAAgB,KACpB,UAAU,CAAC;AAEhB,8CAA8C;AAC9C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,EAAiF,KAChH,KAAK,EAAE,iBAAiB,KACrB,UAAU,CAAC"}

package/dist/dogwood/scan.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Reading the emitted dogwood artifacts back, for the DWD post-synth checks.
+ *
+ * The checks judge the *text*, not the in-memory model, for the same reason
+ * the CED checks judge `policies.cedar.json`: `chant audit` runs over a
+ * checked-in artifact chant did not write, and a wall that only fires on
+ * chant's own output is not a wall. It also means the typed builders and the
+ * walls are independent — DWDC012 catches a windowless `formerly` even though
+ * the builders cannot construct one, because `raw()` and a hand-written `.dw`
+ * both can.
+ *
+ * This is scanning, not parsing. Upstream owns the parser and #1659 owns
+ * shelling to it; what is here is the subset of the surface that answers the
+ * three questions the walls ask, plus enough comment handling not to be fooled
+ * by a commented-out clause.
+ */
+import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+/** One emitted artifact, with everything needed to name it in a finding. */
+export interface DogwoodArtifact {
+    /** The lexicon output it came from. */
+    lexicon: string;
+    /** The filename, which is what a finding points the reader at. */
+    source: string;
+    /** The file's text. */
+    text: string;
+}
+/** Every `.dw` policy file in the build output. */
+export declare function dogwoodPolicyFiles(ctx: PostSynthContext): DogwoodArtifact[];
+/** Every `.dwschema` event-schema file in the build output. */
+export declare function dogwoodSchemaFiles(ctx: PostSynthContext): DogwoodArtifact[];
+/**
+ * Blank out `//` comments, leaving string literals intact.
+ *
+ * String literals stay because a predicate's action id lives inside one
+ * (`Drupe::Action::"Read"`), and blanking those would blind every scan below.
+ * The walk is string-aware in the other direction too: a `//` inside a quoted
+ * value (a URL, say) is not a comment.
+ *
+ * Comment bytes become spaces so every offset in the result still lines up
+ * with the original file.
+ */
+export declare function blankComments(text: string): string;
+/**
+ * The stretches of a `.dw` file that the temporal sub-parser reads: every
+ * `temporal { … }` marker body, and every `def temporal … { … }` macro body.
+ *
+ * Scanning only these is what keeps a Cedar `when { … }` clause from being
+ * mistaken for temporal source — `context.retryWindow == 3` should not read as
+ * a window, and a Cedar attribute named `since` is not the `since` operator.
+ */
+export declare function temporalRegions(text: string): string[];
+/** One `Ns::Action::"Name"::kind` predicate head found in temporal source. */
+export interface TemporalPredicateRef {
+    /** The qualified action, quoted id and all. */
+    action: string;
+    /** The event kind segment after the quoted id. */
+    kind: string;
+}
+/** Every temporal predicate head in a `.dw` file, in source order. */
+export declare function scanPredicates(text: string): TemporalPredicateRef[];
+/** One window literal found in temporal source. */
+export interface WindowRef {
+    /** As written: `48h`. */
+    text: string;
+    seconds: number;
+    /** `within` for an operator's window, `argument` for a bare macro-call interval. */
+    position: "within" | "argument";
+}
+/**
+ * Every window literal in a `.dw` file's temporal source.
+ *
+ * Both shapes count against `max_window`: a macro-call interval is the window
+ * a `within ?w` in the macro body resolves to, so `once(48h, …)` looks back
+ * exactly as far as `formerly within 48h` does.
+ */
+export declare function scanWindows(text: string): WindowRef[];
+/**
+ * Every `formerly` / `previous` / `since` that is not followed by a `within`.
+ *
+ * Unrepresentable through the builders — {@link formerly} and its siblings all
+ * take the window as an argument — but reachable through `raw()`, through a
+ * hand-written `.dw`, and through an audit of a file chant never wrote.
+ */
+export declare function scanWindowlessOperators(text: string): string[];
+/** What a `.dwschema` file says, as far as the walls need to know. */
+export interface EventSchemaFacts {
+    /** Every declared event kind. */
+    kinds: string[];
+    /** The `max_window` directive in seconds, or upstream's 24h default when absent. */
+    maxWindowSeconds: number;
+    /** As written (`30d`), or undefined when the directive is absent. */
+    maxWindowText?: string;
+    /** True when at least one field carries a `pin … = …`. */
+    hasPin: boolean;
+}
+/** Read a `.dwschema` file's declarations. */
+export declare function readEventSchema(text: string): EventSchemaFacts;
+/**
+ * The look-back cap in force for a build.
+ *
+ * With no emitted schema, `ServiceSchema::defaults()` applies and the cap is
+ * 24h. With several, the tightest one wins — a window legal under one schema
+ * and not another is a window some consumer will reject.
+ */
+export declare function effectiveMaxWindowSeconds(schemas: EventSchemaFacts[]): {
+    seconds: number;
+    text: string;
+};
+//# sourceMappingURL=scan.d.ts.map

package/dist/dogwood/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/dogwood/scan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAIzE,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,mDAAmD;AACnD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,GAAG,eAAe,EAAE,CAE3E;AAED,+DAA+D;AAC/D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,GAAG,eAAe,EAAE,CAE3E;AAiBD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAyBlD;AAID;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBtD;AAyBD,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;CACd;AAID,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,EAAE,CASnE;AAED,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,QAAQ,EAAE,QAAQ,GAAG,UAAU,CAAC;CACjC;AAMD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,CAarD;AAOD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAU9D;AAID,sEAAsE;AACtE,MAAM,WAAW,gBAAgB;IAC/B,iCAAiC;IACjC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oFAAoF;IACpF,gBAAgB,EAAE,MAAM,CAAC;IACzB,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0DAA0D;IAC1D,MAAM,EAAE,OAAO,CAAC;CACjB;AAMD,8CAA8C;AAC9C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAkB9D;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,gBAAgB,EAAE,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAaxG"}

package/dist/dogwood/serialize.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The `.dw` serializer leg.
+ *
+ * Runs inside the cedar serializer, not beside it: `serializeDogwood` is
+ * called once the cedar policies have been rendered, and its files land in the
+ * same `SerializerResult`. That is the whole point of shipping dogwood as a
+ * dialect — a `.dw` file stripped of Cedar semantics is meaningless, and a
+ * project's temporal policies and its plain Cedar policies are one policy set
+ * with two halves.
+ *
+ * Nothing here re-implements Cedar rendering. The policy head comes from
+ * `../serializer`'s `renderPolicyHead`, the scope forms from its
+ * `renderScope`, and the `when`/`unless` bodies from its `conditionStrings`,
+ * so a change to how a scope is written moves both outputs at once.
+ */
+import type { Declarable } from "@intentius/chant/declarable";
+/** Files ending in this carry dogwood policy text. */
+export declare const DOGWOOD_POLICY_SUFFIX = ".dw";
+/** Files ending in this carry an event schema. */
+export declare const DOGWOOD_EVENT_SCHEMA_SUFFIX = ".dwschema";
+/** What the leg produced: files to write, and anything the build should say out loud. */
+export interface DogwoodSerializeResult {
+    files: Record<string, string>;
+    warnings: string[];
+}
+/**
+ * One policy, in `.dw` surface syntax.
+ *
+ * Clause order is fixed rather than authored: every `when` form, then every
+ * `unless` form. Cedar evaluates a policy's conditions as a conjunction, and
+ * so does dogwood, so the order carries no meaning — fixing it means a policy
+ * that gains a temporal clause does not reshuffle the ones already there.
+ */
+export declare function renderTemporalPolicyText(id: string, props: Record<string, unknown>): string;
+/**
+ * Render every dogwood entity in the build.
+ *
+ * Returns `undefined` when the build holds no temporal policies, event schemas
+ * or macro libraries at all — a cedar-only project sees no `.dw` output and no
+ * behaviour change.
+ *
+ * Ids come from `resolvePolicyId`, the same rule `cedarPolicyRecords` uses, so
+ * a policy's `@id` does not depend on which leg rendered it.
+ */
+export declare function serializeDogwood(entities: Map<string, Declarable>): DogwoodSerializeResult | undefined;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/dogwood/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/dogwood/serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAgB9D,sDAAsD;AACtD,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAE3C,kDAAkD;AAClD,eAAO,MAAM,2BAA2B,cAAc,CAAC;AAEvD,yFAAyF;AACzF,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAUD;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAgB3F;AA0BD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,sBAAsB,GAAG,SAAS,CAgGtG"}

package/dist/dogwood/temporal.d.ts

@@ -0,0 +1,259 @@
+/**
+ * Typed builders for dogwood's temporal sub-language.
+ *
+ * These target the **parser primitives**, not the named aggregates. The #1657
+ * verification (and the correction comment on epic #1646) is explicit about
+ * why: `formerly`, `previous`, `since`, `exists`, `tp()`, `count for … where`
+ * and `sum … for … where` are the only temporal keywords in upstream's
+ * `extension/temporal/grammar.pest`. `count_within`, `sum_within`,
+ * `count_distinct_within` and `bind` are macros in `default_macros.dw` — a
+ * swappable standard library that a caller passing `--macros` replaces
+ * wholesale — and `once` is not even in that library, only in the examples.
+ *
+ * So the aggregates are expressible here as macro *calls* ({@link call}, and
+ * the convenience wrappers in `./macros.ts`), never as first-class operators.
+ * A call that resolves to nothing at the other end is a missing macro, which
+ * is a comprehensible failure; a first-class builder that silently emits a
+ * name the callee's library does not define is not.
+ *
+ * Everything below renders to the surface syntax the pest grammar accepts.
+ * Where the grammar's precedence would bind differently from the tree the
+ * author built, the renderer parenthesises — it never relies on the reader
+ * knowing that `!` binds tighter than `since`, or that an aggregate's `where`
+ * body is greedy.
+ */
+import { type TemporalWindow, type WindowLike, type WindowParam, type WindowValue } from "./window.js";
+/** What the three past-only operators accept: a window, or a macro's `?w`. */
+export type WindowArgument = WindowLike | WindowParam;
+/**
+ * A binder position: a plain identifier, or a macro sigil.
+ *
+ * The sigils are legal only inside a macro body; upstream's well-formedness
+ * pass rejects them elsewhere. `./macros.ts` is where they belong, and it is
+ * what carries that warning to the author.
+ */
+export declare function binderName(value: string): string;
+/** `(x: T)` — a declaration site in an `exists` or a `for` list. */
+export interface TypedBinder {
+    readonly name: string;
+    readonly type: string;
+}
+/** `(t: Timepoint)`, `(amount: Long)`, `($t: Timepoint)` inside a macro. */
+export declare function typedBinder(name: string, type: string): TypedBinder;
+/** Anything that renders in term position. */
+export type TemporalTerm = TermText | ArrayTerm | CountTerm | SumTerm | CallNode;
+/** A leaf term already in its surface form (a literal, a path, an entity UID). */
+export interface TermText {
+    readonly op: "term";
+    readonly text: string;
+}
+/** `[a, b, c]`. */
+export interface ArrayTerm {
+    readonly op: "array";
+    readonly items: readonly TemporalTerm[];
+}
+/** `count for (t: Timepoint). where φ`. */
+export interface CountTerm {
+    readonly op: "count";
+    readonly binders: readonly TypedBinder[];
+    readonly where: TemporalCondition;
+}
+/** `sum a for (a: Long), (t: Timepoint). where φ`. */
+export interface SumTerm {
+    readonly op: "sum";
+    readonly over: string;
+    readonly binders: readonly TypedBinder[];
+    readonly where: TemporalCondition;
+}
+/**
+ * What a builder accepts in term position.
+ *
+ * Numbers and booleans lift to literals because there is only one thing they
+ * can mean. A bare `string` deliberately does not: `"alice"` is a Cedar string
+ * literal and `alice` is a binder reference, and guessing which one the author
+ * meant is how a policy silently stops matching. Say which with {@link str},
+ * {@link varRef}, {@link ctx} or {@link entityUid}.
+ */
+export type TermInput = TemporalTerm | number | boolean;
+/** A raw term, emitted verbatim. The escape hatch for a shape not modelled here. */
+export declare function term(text: string): TermText;
+/** A Cedar string literal: `"alice"`. */
+export declare function str(value: string): TermText;
+/** An integer literal. Upstream's grammar admits a leading `-`. */
+export declare function int(value: number): TermText;
+/** `true` / `false`. */
+export declare function bool(value: boolean): TermText;
+/** `decimal("1.50")` — Cedar's decimal constructor, which dogwood admits as a term. */
+export declare function decimalOf(value: string): TermText;
+/** `context.input.user` — a field of the request context record. */
+export declare function ctx(path: string): TermText;
+/** `principal`, `resource`, `principal.dept` — the request scope entities. */
+export declare function scopeRef(root: "principal" | "resource", ...attrs: string[]): TermText;
+/** `Drupe::OAuthUser::"alice"` — an entity UID literal. */
+export declare function entityUid(uid: string): TermText;
+/** A bare binder reference — a `for`-declared variable, or a macro sigil. */
+export declare function varRef(name: string): TermText;
+/** `*` — the grammar's wildcard term. */
+export declare function wildcard(): TermText;
+/** `[a, b]`. */
+export declare function arrayOf(...items: TermInput[]): ArrayTerm;
+/**
+ * `count for (t: Timepoint). where φ` — the primitive behind `count_within`.
+ *
+ * The `for` list is the aggregation domain and is mandatory in the grammar,
+ * so it is a required argument here too.
+ */
+export declare function count(binders: TypedBinder[], where: TemporalCondition): CountTerm;
+/** `sum a for (a: Long), (t: Timepoint). where φ` — the primitive behind `sum_within`. */
+export declare function sum(over: string, binders: TypedBinder[], where: TemporalCondition): SumTerm;
+/** Anything that renders in condition position. */
+export type TemporalCondition = PredicateNode | FormerlyNode | PreviousNode | SinceNode | ExistsNode | TpNode | AndNode | NotNode | ComparisonNode | CallNode | SigilCondition | RawCondition;
+/** `Drupe::Action::"Login"::response{ input.user: context.input.user }`. */
+export interface PredicateNode {
+    readonly op: "predicate";
+    readonly action: string;
+    readonly kind: string;
+    readonly args: ReadonlyArray<{
+        readonly path: string;
+        readonly value: TemporalTerm;
+    }>;
+}
+/** `formerly within 1h φ`. */
+export interface FormerlyNode {
+    readonly op: "formerly";
+    readonly window: WindowValue;
+    readonly body: TemporalCondition;
+}
+/** `previous within 30s φ`. */
+export interface PreviousNode {
+    readonly op: "previous";
+    readonly window: WindowValue;
+    readonly body: TemporalCondition;
+}
+/** `φ since within 1h ψ` — infix, with the window on the operator. */
+export interface SinceNode {
+    readonly op: "since";
+    readonly left: TemporalCondition;
+    readonly window: WindowValue;
+    readonly right: TemporalCondition;
+}
+/** `exists (total: Long). φ`. */
+export interface ExistsNode {
+    readonly op: "exists";
+    readonly binder: TypedBinder;
+    readonly body: TemporalCondition;
+}
+/** `tp(t)` — binds the timepoint under evaluation. */
+export interface TpNode {
+    readonly op: "tp";
+    readonly binder: string;
+}
+/** `φ && ψ`. */
+export interface AndNode {
+    readonly op: "and";
+    readonly operands: readonly TemporalCondition[];
+}
+/** `!φ`. */
+export interface NotNode {
+    readonly op: "not";
+    readonly body: TemporalCondition;
+}
+/** `a == b`, `0 < count …`. */
+export interface ComparisonNode {
+    readonly op: "compare";
+    readonly left: TemporalTerm;
+    readonly operator: ComparisonOperator;
+    readonly right: TemporalTerm;
+}
+/** The six operators `cmp_op` admits. */
+export type ComparisonOperator = "==" | "!=" | "<" | "<=" | ">" | ">=";
+/** A macro invocation — `once(1h, φ)`. Legal in both condition and term position. */
+export interface CallNode {
+    readonly op: "call";
+    readonly name: string;
+    readonly args: readonly MacroArg[];
+}
+/** `1h` as a macro-call argument — bare, with no `within` keyword. */
+export interface IntervalArg {
+    readonly op: "interval";
+    readonly window: TemporalWindow;
+}
+/** What a macro call takes: an interval, a condition, or a term. */
+export type MacroArg = IntervalArg | TemporalCondition | TemporalTerm;
+/**
+ * Temporal source text emitted verbatim.
+ *
+ * The one builder that can produce something the walls exist to catch — a
+ * `formerly` with no window, an event kind the schema never declared. That is
+ * deliberate: an escape hatch nobody can reach makes the walls untestable, and
+ * DWDC012 reads the serialized text precisely because this exists.
+ */
+export interface RawCondition {
+    readonly op: "raw";
+    readonly text: string;
+}
+/**
+ * `?s` — a macro parameter standing for an entire condition.
+ *
+ * Its own node rather than a {@link RawCondition} because the grammar treats
+ * it as an atom (`refinable = (predicate | sigil_cond) ~ field_block*`), so
+ * `formerly within ?w ?s` needs no parentheses where arbitrary raw text would.
+ * Build one with `macroCondition()` in `./macros.ts`, which is where the rule
+ * that sigils are legal only inside a macro body is documented.
+ */
+export interface SigilCondition {
+    readonly op: "sigil";
+    readonly param: string;
+}
+/**
+ * `Ns::Action::"Name"::kind{ field: term, … }`.
+ *
+ * The event kind is mandatory in the grammar and author-defined in practice —
+ * `request`/`response`/`error` are the conventional kinds the default event
+ * schema declares, not a fixed set. Which kinds are legal for a given policy
+ * set is the emitted `.dwschema`'s business, and DWDC010's.
+ */
+export declare function predicate(action: string, kind: string, args?: Record<string, TermInput>): PredicateNode;
+/** `formerly within <w> φ` — held at some point in the window. */
+export declare function formerly(w: WindowArgument, body: TemporalCondition): FormerlyNode;
+/** `previous within <w> φ` — held at the immediately preceding timepoint in the window. */
+export declare function previous(w: WindowArgument, body: TemporalCondition): PreviousNode;
+/** `φ since within <w> ψ` — φ has held continuously since ψ, inside the window. */
+export declare function since(left: TemporalCondition, w: WindowArgument, right: TemporalCondition): SinceNode;
+/** `exists (name: Type). φ`. */
+export declare function exists(binder: TypedBinder, body: TemporalCondition): ExistsNode;
+/** `tp(t)`. */
+export declare function tp(binder: string): TpNode;
+/** `φ && ψ && …`. A single operand collapses to itself. */
+export declare function and(...operands: TemporalCondition[]): TemporalCondition;
+/** `!φ`. */
+export declare function not(body: TemporalCondition): NotNode;
+/** `a <op> b`. */
+export declare function compare(left: TermInput, operator: ComparisonOperator, right: TermInput): ComparisonNode;
+/**
+ * A macro invocation.
+ *
+ * Nothing here checks that the macro exists: the library is `--macros`, chosen
+ * by whoever runs `dogwood validate`, and chant is not that. `./macros.ts`
+ * carries typed wrappers for the four the default library ships.
+ */
+export declare function call(name: string, args?: MacroArg[]): CallNode;
+/** `1h` in macro-call argument position — the interval without the `within`. */
+export declare function interval(w: WindowLike): IntervalArg;
+/** Temporal source text, passed through untouched. See {@link RawCondition}. */
+export declare function raw(text: string): RawCondition;
+/** `?s` in condition position. See {@link SigilCondition}. */
+export declare function sigilCondition(param: string): SigilCondition;
+/** Render a term. */
+export declare function renderTerm(t: TemporalTerm): string;
+/** Render a temporal condition to the surface syntax the pest grammar accepts. */
+export declare function renderCondition(node: TemporalCondition): string;
+/**
+ * `temporal { … }` — the extension marker.
+ *
+ * It is a `primary` in the Cedar expression grammar as well as a clause tag,
+ * so this is also how a temporal condition is embedded mid-expression:
+ * `when { is_small(context.input.shares) && temporal { once(1h, …) } }`.
+ */
+export declare function temporalMarker(condition: TemporalCondition): string;
+//# sourceMappingURL=temporal.d.ts.map

package/dist/dogwood/temporal.d.ts.map

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

package/dist/dogwood/upstream.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The dogwood upstream pin.
+ *
+ * Not a `upstreamPin` on the plugin: that slot belongs to the cedar grammar
+ * (`@cedar-policy/cedar-wasm`, see `../spec/pin.ts`), and self-upgrade tooling
+ * bumps exactly one thing per lexicon. Dogwood's pin is a git SHA recorded by
+ * #1657, because upstream has no version to key off — zero tags, zero
+ * releases, and a workspace version of `1.0.0` that is an Amazon-internal
+ * package artifact every future sync will also report.
+ *
+ * The blob hashes are the narrow content pin the #1657 report recommends. The
+ * whole tree hash moves on every sync including docs-only ones, which makes it
+ * too noisy to gate on; these seven files are the surface chant actually
+ * depends on. The three `.pest` grammars pin the language, `default_macros.dw`
+ * pins the standard aggregate library (which is a file a sync can edit and a
+ * caller can replace with `--macros`), and the three `dogwood-cli/src` files
+ * pin the JSON report structs that are #1659's integration surface.
+ *
+ * Movement risk is structural, not incidental: content arrives as squashed
+ * "Sync from internal source" commits from a publish bot, against a repository
+ * nobody outside Amazon can see, with no changelog and no version bump.
+ */
+/** The pinned upstream revision and the files chant's surface is built against. */
+export declare const DOGWOOD_UPSTREAM: {
+    readonly owner: "dogwood-policy";
+    readonly repo: "dogwood";
+    /** Default-branch SHA verified in #1657 (committed 2026-08-06). */
+    readonly revision: "5063bcc2d6d6cf5024d1b0498e6cc8ef52cbcf0c";
+    readonly license: "Apache-2.0";
+    /** Git blob hashes at {@link revision} — the narrow content pin. */
+    readonly contents: {
+        readonly "dogwood-language/src/parser/grammar.pest": "adb0801303ee1b735585fe22a5d85175ecf6772c";
+        readonly "dogwood-language/src/extension/temporal/grammar.pest": "dc31fe1634b5c37173f0a999619e9834069b7a22";
+        readonly "dogwood-language/src/event_schema/grammar.pest": "bd3b064447dc0d09cc2f8eb28a7c657e746cc8a2";
+        readonly "dogwood-language/configuration/default_macros.dw": "ecd67e5edcd566aa66b05ad51bc472afbaf22a7a";
+        readonly "dogwood-cli/src/ops.rs": "2924c7eb0e569a745ff19c2d84cbba782fc56502";
+        readonly "dogwood-cli/src/main.rs": "bfd68c9ff05883ed48e5738f658b5925542d817d";
+        readonly "dogwood-cli/src/error.rs": "43f12afbbf25ad94e25130c83227eefd86f8d516";
+    };
+};
+//# sourceMappingURL=upstream.d.ts.map

package/dist/dogwood/upstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.d.ts","sourceRoot":"","sources":["../../src/dogwood/upstream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,mFAAmF;AACnF,eAAO,MAAM,gBAAgB;;;IAG3B,mEAAmE;;;IAGnE,oEAAoE;;;;;;;;;;CAU5D,CAAC"}