@checkstack/automation-backend 0.2.0 → 0.3.0

package/src/schema.ts

@@ -5,6 +5,7 @@ import {
   jsonb,
   integer,
   index,
+  uniqueIndex,
 } from "drizzle-orm/pg-core";
 
 /**
@@ -20,6 +21,12 @@ export const automations = pgTable(
       .$defaultFn(() => crypto.randomUUID()),
     name: text("name").notNull(),
     description: text("description"),
+    /**
+     * Optional grouping label (HA-style "category"). A row field like
+     * name/description — NOT part of the definition JSON. `group` is a SQL
+     * reserved word; drizzle quotes the column name so it is safe.
+     */
+    group: text("group"),
     /** "enabled" | "disabled" */
     status: text("status").notNull().default("enabled"),
     /** Validated AutomationDefinition (zod-checked on write). */
@@ -38,6 +45,7 @@ export const automations = pgTable(
   (t) => ({
     statusIdx: index("automations_status_idx").on(t.status),
     managedByIdx: index("automations_managed_by_idx").on(t.managedBy),
+    groupIdx: index("automations_group_idx").on(t.group),
   }),
 );
 
@@ -200,19 +208,35 @@ export const automationWaitLocks = pgTable(
       .references(() => automationRuns.id, { onDelete: "cascade" }),
     /** Action path of the suspended node — used to resume from the next sibling. */
     actionPath: text("action_path").notNull(),
-    /** Discriminator: "trigger" (wait_for_trigger) or "delay" (queue-backed sleep). */
+    /**
+     * Discriminator:
+     *   - "trigger" — wait_for_trigger (woken by a matching event)
+     *   - "delay"   — queue-backed sleep
+     *   - "until"   — wait_until: polled condition re-check on an interval
+     */
     kind: text("kind").notNull().default("trigger"),
-    /** Fully qualified event id being awaited (only meaningful when kind = "trigger"). */
+    /**
+     * Fully qualified event id being awaited (only meaningful when
+     * kind = "trigger"). For "delay" / "until" a synthetic marker.
+     */
     eventId: text("event_id").notNull(),
     /** Optional context-key filter (e.g. same incidentId). */
     contextKey: text("context_key"),
     /** Optional template that must evaluate truthy on the arriving payload. */
     filterTemplate: text("filter_template"),
+    /**
+     * Config for `kind = "until"` — the condition to re-evaluate, the
+     * poll interval, and the timeout behaviour. JSON because the
+     * condition may be a structured object, not just a template string.
+     */
+    waitConfig: jsonb("wait_config").$type<Record<string, unknown>>(),
     /**
      * Absolute deadline. For `kind = "trigger"`: nullable; if set, the
      * sweeper fails the run when exceeded. For `kind = "delay"`:
      * required; the firing time after which the run should resume even
-     * if the queue job is lost.
+     * if the queue job is lost. For `kind = "until"`: optional wait
+     * deadline (null = wait forever); the sweeper re-ticks "until" locks
+     * regardless, so a lost re-check job still self-heals.
      */
     timeoutAt: timestamp("timeout_at"),
     createdAt: timestamp("created_at").defaultNow().notNull(),
@@ -227,6 +251,8 @@ export const automationWaitLocks = pgTable(
     timeoutIdx: index("automation_wait_locks_timeout_idx").on(t.timeoutAt),
     /** Powers the run-detail UI's "what are we waiting on?" view. */
     runIdx: index("automation_wait_locks_run_idx").on(t.runId),
+    /** Powers the sweeper's "re-tick all until locks" scan. */
+    kindIdx: index("automation_wait_locks_kind_idx").on(t.kind),
   }),
 );
 
@@ -271,6 +297,139 @@ export const automationRunState = pgTable(
   }),
 );
 
+/**
+ * Pre-run dwell timers — the durable backing for a trigger's `for:`
+ * dwell ("fire only if the matched state still holds after Y").
+ *
+ * A dwell is a property of the *trigger* and arms BEFORE any run exists,
+ * so it cannot reuse `automation_wait_locks` (whose `runId` is NOT NULL).
+ * The row is the source of truth; an `automation-dwell` queue job is just
+ * the wake signal. Cancellation is DB-side (delete the row) — the queue
+ * job pops later and no-ops because the row is gone (constraint 2).
+ *
+ *   - `armedStatus` — the status snapshotted at arm time; the expiry
+ *     re-confirm proceeds only if the system is still in this status.
+ *   - `fireAt` — absolute deadline; the queue job carries the matching
+ *     `startDelay`, and the sweeper catches expired rows whose job was
+ *     lost.
+ *   - `payloadSnapshot` / `actorSnapshot` — the firing event's payload +
+ *     actor, replayed into the run when the dwell fires.
+ *
+ * Unique on `(automationId, triggerId, contextKey)` so a re-fire re-arms
+ * the same row (pushes `fireAt`) rather than stacking duplicate timers.
+ */
+export const automationDwellTimers = pgTable(
+  "automation_dwell_timers",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    automationId: text("automation_id")
+      .notNull()
+      .references(() => automations.id, { onDelete: "cascade" }),
+    /** Operator-assigned or derived trigger id this dwell belongs to. */
+    triggerId: text("trigger_id").notNull(),
+    /** Fully qualified event id that armed the dwell. */
+    eventId: text("event_id").notNull(),
+    /** Durable context key (typically the systemId). Nullable. */
+    contextKey: text("context_key"),
+    /**
+     * Status the system was in when the dwell armed. The expiry
+     * re-confirm fires the run only if the system is still in this
+     * status. Null when no live status was resolvable at arm time
+     * (re-confirm then proceeds without a status gate).
+     */
+    armedStatus: text("armed_status"),
+    /** Firing event payload, replayed into the run on fire. */
+    payloadSnapshot: jsonb("payload_snapshot")
+      .notNull()
+      .$type<Record<string, unknown>>(),
+    /** Firing event actor, replayed into the run on fire. */
+    actorSnapshot: jsonb("actor_snapshot")
+      .notNull()
+      .$type<Record<string, unknown>>(),
+    /** Absolute deadline (now + for). */
+    fireAt: timestamp("fire_at").notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (t) => ({
+    /**
+     * Addressable for re-arm + cancellation. Postgres treats NULLs as
+     * distinct in a unique index, so the rare null-context-key dwell
+     * cannot rely on ON CONFLICT to de-dupe; the store handles that case
+     * with an explicit find-then-update (see dwell-store.ts). Non-null
+     * keys (the common systemId case) de-dupe via this index.
+     */
+    keyUnique: uniqueIndex("automation_dwell_timers_key_unique").on(
+      t.automationId,
+      t.triggerId,
+      t.contextKey,
+    ),
+    /** Powers the sweeper's expired-dwell scan. */
+    fireAtIdx: index("automation_dwell_timers_fire_at_idx").on(t.fireAt),
+    /** Powers cleanup of dwells for a deleted/disabled automation. */
+    automationIdx: index("automation_dwell_timers_automation_idx").on(
+      t.automationId,
+    ),
+  }),
+);
+
+/**
+ * Windowed-count / rate trigger occurrence log.
+ *
+ * Backs a trigger's `window: { count, minutes, refire }` gate. One row is
+ * appended per QUALIFYING occurrence (the structured config gate + the
+ * operator's `filter` have already passed) on the single pod that claimed
+ * the emission from the work queue, then the engine counts rows within the
+ * trailing window to decide whether to fire.
+ *
+ * Append-log (not a rolling counter) because a SLIDING window is "count rows
+ * newer than now - M": a counter has no per-occurrence timestamps to age out
+ * and so can only tumble, not slide. This mirrors the former healthcheck
+ * `health_check_unhealthy_transitions` shape, relocated into the engine so
+ * any trigger can use it (generic mechanism).
+ *
+ * State-and-scale: the row is durable Postgres; the COUNT read is pure SQL,
+ * so every pod computes the same answer. The single INSERT happens on the
+ * work-queue-claiming pod, so there is no double-count. Pruned by the
+ * stalled-sweeper (rows older than the 24h schema cap are dead). The FK
+ * cascade is the entire delete-lifecycle (exactly like `automation_dwell_timers`).
+ */
+export const automationWindowEvents = pgTable(
+  "automation_window_events",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    automationId: text("automation_id")
+      .notNull()
+      .references(() => automations.id, { onDelete: "cascade" }),
+    /** Operator-assigned or derived trigger id this window belongs to. */
+    triggerId: text("trigger_id").notNull(),
+    /** Fully qualified base event id whose occurrences are being counted. */
+    eventId: text("event_id").notNull(),
+    /** Durable context key (typically the systemId). Nullable. */
+    contextKey: text("context_key"),
+    /** When the qualifying occurrence happened. */
+    occurredAt: timestamp("occurred_at").defaultNow().notNull(),
+  },
+  (t) => ({
+    /**
+     * Powers the in-window COUNT(*): rows for one
+     * `(automationId, triggerId, contextKey)` whose `occurredAt` is within the
+     * trailing window. `occurredAt` is the trailing-range column.
+     */
+    countIdx: index("automation_window_events_count_idx").on(
+      t.automationId,
+      t.triggerId,
+      t.contextKey,
+      t.occurredAt,
+    ),
+    /** Powers the sweeper's TTL prune scan (delete rows older than the cap). */
+    pruneIdx: index("automation_window_events_prune_idx").on(t.occurredAt),
+  }),
+);
+
 /**
  * Subscription-migration failures.
  *
@@ -308,3 +467,77 @@ export const automationMigrationFailures = pgTable(
     createdAt: timestamp("created_at").defaultNow().notNull(),
   },
 );
+
+/**
+ * Generic transition log — generalizes Phase 13's
+ * `health_check_state_transitions` to ANY entity field. One row is
+ * appended per changed tracked field on a real diff; powers
+ * `inStateSince` / `inStateForMs` / `transitionCount` for arbitrary
+ * entities.
+ */
+export const entityTransitions = pgTable(
+  "entity_transitions",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    kind: text("kind").notNull(),
+    entityId: text("entity_id").notNull(),
+    field: text("field").notNull(),
+    fromValue: text("from_value"),
+    toValue: text("to_value").notNull(),
+    transitionedAt: timestamp("transitioned_at").defaultNow().notNull(),
+  },
+  (t) => ({
+    // Generalizes health_check_state_transitions lookup idx
+    // (healthcheck schema.ts:176): "most recent transition into status X".
+    lookupIdx: index("entity_transitions_lookup_idx").on(
+      t.kind,
+      t.entityId,
+      t.field,
+      t.transitionedAt,
+    ),
+  }),
+);
+
+/**
+ * Wake-index — the reactive `wait_until` dependency set (reactive
+ * automation engine §8.1). A suspended `wait_until` extracts the
+ * `state.*` refs its condition reads and inserts one row here per ref,
+ * all pointing at the owning `automation_wait_locks` row (`kind = "until"`).
+ *
+ * Rather than overloading the single `(eventId, contextKey)` columns on
+ * `automation_wait_locks`, this child table lets one wait depend on a SET
+ * of refs across any kinds. Stage-1 routing answers "which waits depend on
+ * this just-changed `kind:id` ref?" with an indexed intersection join (§8.2).
+ *
+ * `ref` is `${kind}:${id}` (e.g. "incident:abc", "health:sys-1"), or the
+ * kind-level wildcard `${kind}:*` when extraction couldn't resolve a
+ * concrete id (§8.3 — the wait then wakes on ANY change of that kind and
+ * re-evaluates). The `(waitLockId, ref)` pair is uniquely indexed so a
+ * concurrent arm race can't double-insert the same dependency (§14.4 #3).
+ */
+export const automationWakeIndex = pgTable(
+  "automation_wake_index",
+  {
+    id: text("id")
+      .primaryKey()
+      .$defaultFn(() => crypto.randomUUID()),
+    waitLockId: text("wait_lock_id")
+      .notNull()
+      .references(() => automationWaitLocks.id, { onDelete: "cascade" }),
+    /** The dependency ref: `${kind}:${id}` or the kind wildcard `${kind}:*`. */
+    ref: text("ref").notNull(),
+  },
+  (t) => ({
+    /** Stage-1 lookup: "which waits depend on this just-changed ref?" */
+    refIdx: index("automation_wake_index_ref_idx").on(t.ref),
+    /** Cascade-friendly per-lock lookups + the arm-race uniqueness guard. */
+    lockIdx: index("automation_wake_index_lock_idx").on(t.waitLockId),
+    /** A wait depends on each distinct ref at most once (ON CONFLICT arm). */
+    lockRefUnique: uniqueIndex("automation_wake_index_lock_ref_unique").on(
+      t.waitLockId,
+      t.ref,
+    ),
+  }),
+);

package/src/script-test-replay.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test";
+import {
+  buildReplayArtifacts,
+  buildReplayContext,
+} from "./script-test-replay";
+
+describe("buildReplayArtifacts", () => {
+  test("keys by artifact type and by action id", () => {
+    const out = buildReplayArtifacts([
+      { artifactType: "jira.issue", actionId: "create_issue", data: { key: "P-1" } },
+    ]);
+    expect(out["jira.issue"]).toEqual({ key: "P-1" });
+    expect(out.create_issue).toEqual({ key: "P-1" });
+  });
+
+  test("omits the action-id key when actionId is null", () => {
+    const out = buildReplayArtifacts([
+      { artifactType: "shell_result", actionId: null, data: { exitCode: 0 } },
+    ]);
+    expect(out.shell_result).toEqual({ exitCode: 0 });
+    expect(Object.keys(out)).toEqual(["shell_result"]);
+  });
+
+  test("later artifacts of the same key win", () => {
+    const out = buildReplayArtifacts([
+      { artifactType: "jira.issue", actionId: null, data: { key: "OLD" } },
+      { artifactType: "jira.issue", actionId: null, data: { key: "NEW" } },
+    ]);
+    expect(out["jira.issue"]).toEqual({ key: "NEW" });
+  });
+});
+
+describe("buildReplayContext", () => {
+  const run = {
+    triggerEventId: "incident.incident.created",
+    triggerPayload: { id: "INC-7", severity: "high" },
+  };
+
+  test("builds trigger + artifacts; empty var/no repeat without a snapshot", () => {
+    const ctx = buildReplayContext({
+      run,
+      artifacts: [
+        { artifactType: "jira.issue", actionId: "j", data: { key: "P-9" } },
+      ],
+    });
+    expect(ctx.trigger).toEqual({
+      event: "incident.incident.created",
+      payload: { id: "INC-7", severity: "high" },
+    });
+    expect(ctx.artifacts).toEqual({
+      "jira.issue": { key: "P-9" },
+      j: { key: "P-9" },
+    });
+    expect(ctx.var).toEqual({});
+    expect("repeat" in ctx).toBe(false);
+  });
+
+  test("pulls var and repeat from an in-flight scope snapshot", () => {
+    const ctx = buildReplayContext({
+      run,
+      artifacts: [],
+      scopeSnapshot: {
+        vars: { attempts: 2 },
+        repeat: { index: 1, item: { name: "b" } },
+      },
+    });
+    expect(ctx.var).toEqual({ attempts: 2 });
+    expect(ctx.repeat).toEqual({ index: 1, item: { name: "b" } });
+  });
+
+  test("ignores a malformed repeat in the snapshot", () => {
+    const ctx = buildReplayContext({
+      run,
+      artifacts: [],
+      scopeSnapshot: { repeat: { item: "no-index" } },
+    });
+    expect("repeat" in ctx).toBe(false);
+  });
+
+  test("ignores a non-object vars snapshot", () => {
+    const ctx = buildReplayContext({
+      run,
+      artifacts: [],
+      scopeSnapshot: { vars: "nope" },
+    });
+    expect(ctx.var).toEqual({});
+  });
+});

package/src/script-test-replay.ts

@@ -0,0 +1,100 @@
+/**
+ * Replay support for the in-UI script test panel.
+ *
+ * Reconstructs an editable {@link ScriptTestContext} from a real automation
+ * run so an operator can debug a `run_script` / `run_shell` action against
+ * the data a past (or in-flight) run actually saw, instead of a synthetic
+ * sample.
+ *
+ * Data sources, in order of durability:
+ *   - `automation_runs` — always present; gives `trigger.event` +
+ *     `trigger.payload`.
+ *   - `automation_artifacts` — persisted per run; rebuilt into the
+ *     `artifacts` record keyed by artifact type (and by action id), matching
+ *     what `run_script` exposes as `context.artifacts`.
+ *   - `automation_run_state.scopeSnapshot` — present only while the run is
+ *     in-flight / suspended (cleared at terminal status). When available it
+ *     supplies `var` and `repeat`; otherwise those are empty, which is fine
+ *     for editing a fresh test.
+ *
+ * Pure data-shaping over already-fetched rows so it is unit-testable without
+ * a DB.
+ */
+import type { ScriptTestContext } from "@checkstack/automation-common";
+
+export interface ReplayRunRow {
+  triggerEventId: string;
+  triggerPayload: Record<string, unknown>;
+}
+
+export interface ReplayArtifactRow {
+  artifactType: string;
+  actionId: string | null;
+  data: Record<string, unknown>;
+}
+
+/**
+ * Build the `artifacts` record a script sees, keyed by artifact type and
+ * (when set) by action id. Mirrors the dispatch engine's exposure so a
+ * replayed context matches runtime. Later artifacts of the same key win
+ * (callers pass rows in chronological order).
+ */
+export function buildReplayArtifacts(
+  rows: ReplayArtifactRow[],
+): Record<string, unknown> {
+  const artifacts: Record<string, unknown> = {};
+  for (const row of rows) {
+    artifacts[row.artifactType] = row.data;
+    if (row.actionId) {
+      artifacts[row.actionId] = row.data;
+    }
+  }
+  return artifacts;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function extractRepeat(
+  snapshot: Record<string, unknown> | undefined,
+): ScriptTestContext["repeat"] {
+  const repeat = snapshot?.repeat;
+  if (!isRecord(repeat)) return undefined;
+  if (typeof repeat.index !== "number") return undefined;
+  return {
+    index: repeat.index,
+    ...(repeat.item === undefined ? {} : { item: repeat.item }),
+  };
+}
+
+/**
+ * Assemble the editable replay context from already-fetched run rows.
+ *
+ * @param run - the `automation_runs` row (trigger source of truth)
+ * @param artifacts - persisted artifacts for the run, chronological
+ * @param scopeSnapshot - `automation_run_state.scopeSnapshot` if the run is
+ *   still in-flight / suspended, else undefined
+ */
+export function buildReplayContext({
+  run,
+  artifacts,
+  scopeSnapshot,
+}: {
+  run: ReplayRunRow;
+  artifacts: ReplayArtifactRow[];
+  scopeSnapshot?: Record<string, unknown>;
+}): ScriptTestContext {
+  const vars = isRecord(scopeSnapshot?.vars) ? scopeSnapshot.vars : {};
+  const repeat = extractRepeat(scopeSnapshot);
+
+  return {
+    trigger: {
+      event: run.triggerEventId,
+      payload: run.triggerPayload,
+    },
+    artifacts: buildReplayArtifacts(artifacts),
+    var: vars,
+    ...(repeat ? { repeat } : {}),
+  };
+}

package/src/script-test-shell-env.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import { flattenScopeToShellEnv } from "./script-test-shell-env";
+
+describe("flattenScopeToShellEnv (test context)", () => {
+  test("emits trigger.event even for an empty context", () => {
+    expect(flattenScopeToShellEnv(undefined)).toEqual({
+      CHECKSTACK_TRIGGER_EVENT: "",
+    });
+  });
+
+  test("flattens nested payload objects into dotted env keys", () => {
+    const env = flattenScopeToShellEnv({
+      trigger: { event: "incident.created", payload: { id: "INC-1", nested: { level: 2 } } },
+    });
+    expect(env.CHECKSTACK_TRIGGER_EVENT).toBe("incident.created");
+    expect(env.CHECKSTACK_TRIGGER_PAYLOAD_ID).toBe("INC-1");
+    expect(env.CHECKSTACK_TRIGGER_PAYLOAD_NESTED_LEVEL).toBe("2");
+  });
+
+  test("indexes array elements and emits a newline-joined whole-array var", () => {
+    const env = flattenScopeToShellEnv({
+      trigger: { event: "e", payload: { tags: ["a", "b"] } },
+    });
+    expect(env.CHECKSTACK_TRIGGER_PAYLOAD_TAGS).toBe("a\nb");
+    expect(env.CHECKSTACK_TRIGGER_PAYLOAD_TAGS_0).toBe("a");
+    expect(env.CHECKSTACK_TRIGGER_PAYLOAD_TAGS_1).toBe("b");
+  });
+
+  test("flattens artifacts, vars and repeat", () => {
+    const env = flattenScopeToShellEnv({
+      trigger: { event: "e" },
+      artifacts: { jira_issue: { key: "PROJ-1" } },
+      var: { count: 5 },
+      repeat: { index: 3, item: { name: "x" } },
+    });
+    expect(env.CHECKSTACK_ARTIFACT_JIRA_ISSUE_KEY).toBe("PROJ-1");
+    expect(env.CHECKSTACK_VAR_COUNT).toBe("5");
+    expect(env.CHECKSTACK_REPEAT_INDEX).toBe("3");
+    expect(env.CHECKSTACK_REPEAT_ITEM_NAME).toBe("x");
+  });
+});

package/src/script-test-shell-env.ts

@@ -0,0 +1,89 @@
+/**
+ * Flatten a sample test context into the `CHECKSTACK_*` environment
+ * variables a `run_shell` script receives.
+ *
+ * Mirrors `flattenScopeToShellEnv` in `@checkstack/integration-script-backend`
+ * (which operates on a real `ActionRunScope`) but works on the editable
+ * {@link ScriptTestContext} the test panel sends. Names are produced via the
+ * shared {@link toShellEnvKey} rule so the injected vars match the editor's
+ * `$` autocomplete suggestions exactly.
+ */
+import { toShellEnvKey } from "@checkstack/automation-common";
+import type { ScriptTestContext } from "./script-test";
+
+function isScalar(value: unknown): value is string | number | boolean {
+  return (
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean"
+  );
+}
+
+/**
+ * Walk a value, writing one env var per scalar leaf keyed by its dotted
+ * path. Plain objects recurse; arrays emit a single newline-separated var
+ * at the current path AND recurse into each element by numeric index.
+ */
+function flattenInto(
+  value: unknown,
+  path: string,
+  out: Record<string, string>,
+): void {
+  if (isScalar(value)) {
+    out[toShellEnvKey(path)] = String(value);
+    return;
+  }
+  if (value === null || value === undefined) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    out[toShellEnvKey(path)] = value
+      .map((element) =>
+        isScalar(element) ? String(element) : JSON.stringify(element),
+      )
+      .join("\n");
+    for (const [index, element] of value.entries()) {
+      flattenInto(element, `${path}[${index}]`, out);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, child] of Object.entries(
+      value as Record<string, unknown>,
+    )) {
+      flattenInto(child, `${path}.${key}`, out);
+    }
+    return;
+  }
+}
+
+/**
+ * Build the `CHECKSTACK_*` env var map for a shell test run from the
+ * editable sample context. Paths mirror the editor's scope field paths
+ * (`trigger.event`, `trigger.payload.*`, `artifact.<type>.*`, `var.*`,
+ * `repeat.*`).
+ */
+export function flattenScopeToShellEnv(
+  context: ScriptTestContext | undefined,
+): Record<string, string> {
+  const out: Record<string, string> = {
+    [toShellEnvKey("trigger.event")]: context?.trigger?.event ?? "",
+  };
+
+  flattenInto(context?.trigger?.payload ?? {}, "trigger.payload", out);
+
+  for (const [type, data] of Object.entries(context?.artifacts ?? {})) {
+    flattenInto(data, `artifact.${type}`, out);
+  }
+  for (const [name, value] of Object.entries(context?.var ?? {})) {
+    flattenInto(value, `var.${name}`, out);
+  }
+  if (context?.repeat) {
+    out[toShellEnvKey("repeat.index")] = String(context.repeat.index);
+    if (context.repeat.item !== undefined) {
+      flattenInto(context.repeat.item, "repeat.item", out);
+    }
+  }
+
+  return out;
+}