@agent-native/core 0.209.2 → 0.209.3-nightly-20261016212700

package/dist/client/motion-text.js

@@ -8,6 +8,18 @@ const MOTION_TEXT_UNITS = new Set([
     "line",
     "paragraph",
 ]);
+const MOTION_TEXT_ORDERS = new Set([
+    "left-to-right",
+    "right-to-left",
+    "center-out",
+    "random",
+    "top-to-bottom",
+    "bottom-to-top",
+]);
+const MOTION_TEXT_ANIMATION_DIRECTIONS = new Set([
+    "in",
+    "out",
+]);
 const MOTION_TEXT_PROPERTIES = new Set([
     "opacity",
     "translate",
@@ -61,6 +73,7 @@ const INLINE_TEXT_TAGS = new Set([
 ]);
 const MAX_TEXT_UNITS = 512;
 const PREVIEW_MESSAGE_TYPES = new Set([
+    "motion-preview-duration-request",
     "motion-preview",
     "motion-preview-clear",
 ]);
@@ -137,30 +150,50 @@ export function AgentNativeMotionText({ animation, animations: animationList, pl
         if (groupCount > MAX_TEXT_UNITS) {
             throw new Error(`AgentNativeMotionText supports at most ${MAX_TEXT_UNITS} animated units.`);
         }
-        if ((groupCount - 1) * primaryAnimation.staggerMs > 120_000) {
-            throw new Error("AgentNativeMotionText stagger exceeds the 120000ms runtime limit.");
-        }
+        const animationSchedules = animations.map((track) => {
+            const overlap = track.overlapPercent;
+            const durationMs = overlap === undefined
+                ? track.durationMs
+                : track.durationMs /
+                    (1 + Math.max(0, groupCount - 1) * (1 - overlap / 100));
+            const staggerMs = overlap === undefined
+                ? track.staggerMs
+                : durationMs * (1 - overlap / 100);
+            const spanMs = (track.delayMs ?? 0) + (groupCount - 1) * staggerMs + durationMs;
+            if (!Number.isFinite(spanMs) || spanMs > 120_000) {
+                throw new Error("AgentNativeMotionText animation span exceeds the 120000ms runtime limit.");
+            }
+            return { track, durationMs, staggerMs };
+        });
+        const orderRanks = textOrderRanks(groupCount, motionTextOrder(primaryAnimation), `${primaryAnimation.targetNodeId}|${hostElement.textContent ?? ""}`);
         const previewAnimations = [];
         try {
-            for (const track of animations) {
+            for (const { track, durationMs, staggerMs } of animationSchedules) {
                 for (const entry of elements) {
                     if (typeof entry.element.animate !== "function") {
                         throw new Error("AgentNativeMotionText requires the Web Animations API.");
                     }
-                    const delayIndex = track.direction === "reverse"
-                        ? groupCount - 1 - entry.index
-                        : entry.index;
+                    const delayIndex = orderRanks[entry.index] ?? entry.index;
                     const easingStyle = track.keyframes.some((keyframe) => isMotionEaseVariableReference(keyframe.ease ?? ""))
                         ? window.getComputedStyle(entry.element)
                         : null;
-                    const keyframes = track.keyframes.map((keyframe) => ({
-                        offset: keyframe.t,
-                        easing: resolveMotionEaseForWebAnimations(keyframe.ease ?? "ease", (name) => easingStyle?.getPropertyValue(name) ?? ""),
-                        [track.property]: keyframe.value,
-                    }));
-                    const delay = (track.delayMs ?? 0) + delayIndex * track.staggerMs;
+                    const animationDirection = motionTextAnimationDirection(track);
+                    const keyframes = (animationDirection === "out"
+                        ? [...track.keyframes].reverse()
+                        : track.keyframes).map((keyframe, keyframeIndex) => {
+                        const easingKeyframe = animationDirection === "out" &&
+                            keyframeIndex < track.keyframes.length - 1
+                            ? track.keyframes[track.keyframes.length - 2 - keyframeIndex]
+                            : keyframe;
+                        return {
+                            offset: animationDirection === "out" ? 1 - keyframe.t : keyframe.t,
+                            easing: resolveMotionEaseForWebAnimations(easingKeyframe.ease ?? "ease", (name) => easingStyle?.getPropertyValue(name) ?? ""),
+                            [track.property]: keyframe.value,
+                        };
+                    });
+                    const delay = (track.delayMs ?? 0) + delayIndex * staggerMs;
                     const runningAnimation = entry.element.animate(keyframes, {
-                        duration: track.durationMs,
+                        duration: durationMs,
                         delay,
                         iterations: playbackMode === "once" ? 1 : Infinity,
                         direction: playbackMode === "ping-pong" ? "alternate" : "normal",
@@ -169,7 +202,7 @@ export function AgentNativeMotionText({ animation, animations: animationList, pl
                     previewAnimations.push({
                         animation: runningAnimation,
                         delay,
-                        durationMs: track.durationMs,
+                        durationMs,
                     });
                 }
             }
@@ -180,12 +213,21 @@ export function AgentNativeMotionText({ animation, animations: animationList, pl
             }
             throw error;
         }
+        const textTimelineDurationMs = previewAnimations.reduce((duration, entry) => Math.max(duration, entry.delay + entry.durationMs), 0);
+        const previewSpanKey = `react:${primaryAnimation.targetNodeId}`;
+        const reportPreviewSpanDuration = (durationMs) => {
+            window.parent.postMessage({ type: "motion-preview-span", key: previewSpanKey, durationMs }, "*");
+        };
         let isPreviewing = false;
         const handlePreviewMessage = (event) => {
             if (event.source !== window.parent ||
                 !isMotionPreviewMessage(event.data)) {
                 return;
             }
+            if (event.data.type === "motion-preview-duration-request") {
+                reportPreviewSpanDuration(textTimelineDurationMs);
+                return;
+            }
             if (event.data.type === "motion-preview-clear") {
                 if (!isPreviewing)
                     return;
@@ -197,28 +239,33 @@ export function AgentNativeMotionText({ animation, animations: animationList, pl
                 return;
             }
             const t = Number(event.data.t);
-            const timelineDuration = Number(event.data.durationMs);
-            if (!Number.isFinite(t) || !Number.isFinite(timelineDuration))
+            const requestedTimelineDuration = Number(event.data.durationMs);
+            if (!Number.isFinite(t) || !Number.isFinite(requestedTimelineDuration)) {
                 return;
-            if (timelineDuration <= 0)
+            }
+            if (requestedTimelineDuration <= 0)
                 return;
+            if (textTimelineDurationMs > requestedTimelineDuration) {
+                reportPreviewSpanDuration(textTimelineDurationMs);
+            }
             if (!isPreviewing) {
                 isPreviewing = true;
                 for (const entry of previewAnimations)
                     entry.animation.pause();
             }
-            const timelineTime = Math.max(0, Math.min(1, t)) * timelineDuration;
+            const timelineTime = Math.max(0, Math.min(1, t)) * requestedTimelineDuration;
             for (const entry of previewAnimations) {
-                const elapsed = Math.max(0, timelineTime - entry.delay);
                 entry.animation.currentTime =
                     playbackMode === "once"
-                        ? Math.min(entry.durationMs, elapsed)
-                        : elapsed;
+                        ? Math.min(entry.delay + entry.durationMs, timelineTime)
+                        : timelineTime;
             }
         };
         window.addEventListener("message", handlePreviewMessage);
+        reportPreviewSpanDuration(textTimelineDurationMs);
         return () => {
             window.removeEventListener("message", handlePreviewMessage);
+            reportPreviewSpanDuration(0);
             for (const entry of previewAnimations) {
                 entry.animation.cancel();
             }
@@ -242,14 +289,23 @@ function validateAnimations(animations) {
         throw new Error("AgentNativeMotionText requires at least one animation.");
     }
     const first = animations[0];
+    const firstOrder = motionTextOrder(first);
+    const firstAnimationDirection = motionTextAnimationDirection(first);
+    const firstIgnoreSpaces = motionTextIgnoreSpaces(first);
     const properties = new Set();
     for (const animation of animations) {
         validateAnimation(animation);
         if (animation.targetNodeId !== first.targetNodeId ||
             animation.unit !== first.unit ||
             animation.direction !== first.direction ||
-            animation.staggerMs !== first.staggerMs) {
-            throw new Error("AgentNativeMotionText animations for one target must share target, unit, direction, and stagger.");
+            motionTextAnimationDirection(animation) !== firstAnimationDirection ||
+            motionTextOrder(animation) !== firstOrder ||
+            animation.overlapPercent !== first.overlapPercent ||
+            (animation.unit === "character" &&
+                motionTextIgnoreSpaces(animation) !== firstIgnoreSpaces) ||
+            (animation.overlapPercent === undefined &&
+                animation.staggerMs !== first.staggerMs)) {
+            throw new Error("AgentNativeMotionText animations for one target must share target, unit, direction, animation direction, order, overlap, character whitespace, and fixed stagger settings.");
         }
         if (properties.has(animation.property)) {
             throw new Error(`AgentNativeMotionText property "${animation.property}" is duplicated.`);
@@ -271,12 +327,36 @@ function validateAnimation(animation) {
     if (animation.direction !== "forward" && animation.direction !== "reverse") {
         throw new Error("AgentNativeMotionText direction is unsupported.");
     }
+    if (animation.animationDirection !== undefined &&
+        !MOTION_TEXT_ANIMATION_DIRECTIONS.has(animation.animationDirection)) {
+        throw new Error("AgentNativeMotionText animationDirection is unsupported.");
+    }
+    if (animation.order !== undefined &&
+        !MOTION_TEXT_ORDERS.has(animation.order)) {
+        throw new Error("AgentNativeMotionText order is unsupported.");
+    }
+    if ((animation.order === "top-to-bottom" ||
+        animation.order === "bottom-to-top") &&
+        animation.unit !== "line" &&
+        animation.unit !== "paragraph") {
+        throw new Error("AgentNativeMotionText vertical order requires line or paragraph units.");
+    }
+    if (animation.overlapPercent !== undefined &&
+        (!Number.isFinite(animation.overlapPercent) ||
+            animation.overlapPercent < 0 ||
+            animation.overlapPercent > 100)) {
+        throw new Error("AgentNativeMotionText overlapPercent must be between 0 and 100.");
+    }
+    if (animation.ignoreSpaces !== undefined &&
+        typeof animation.ignoreSpaces !== "boolean") {
+        throw new Error("AgentNativeMotionText ignoreSpaces must be a boolean.");
+    }
     if (!MOTION_TEXT_PROPERTIES.has(animation.property)) {
         throw new Error("AgentNativeMotionText property is unsupported.");
     }
     if (!Number.isFinite(animation.staggerMs) ||
         animation.staggerMs < 0 ||
-        animation.staggerMs > 5000) {
+        animation.staggerMs > 120_000) {
         throw new Error("AgentNativeMotionText staggerMs is invalid.");
     }
     if (animation.delayMs !== undefined &&
@@ -321,7 +401,46 @@ function assignRef(ref, value) {
     else if (ref)
         ref.current = value;
 }
-function textTokens(text, unit) {
+function motionTextAnimationDirection(animation) {
+    return animation.animationDirection ?? "in";
+}
+function motionTextOrder(animation) {
+    return (animation.order ??
+        (animation.direction === "reverse" ? "right-to-left" : "left-to-right"));
+}
+function motionTextIgnoreSpaces(animation) {
+    return animation.ignoreSpaces ?? true;
+}
+function textOrderRanks(count, order, seed) {
+    const indexes = Array.from({ length: count }, (_, index) => index);
+    if (order === "right-to-left" || order === "bottom-to-top") {
+        indexes.reverse();
+    }
+    else if (order === "center-out") {
+        const center = (count - 1) / 2;
+        indexes.sort((left, right) => Math.abs(left - center) - Math.abs(right - center) || left - right);
+    }
+    else if (order === "random") {
+        let state = 2_166_136_261;
+        for (let index = 0; index < seed.length; index += 1) {
+            state = Math.imul(state ^ seed.charCodeAt(index), 16_777_619);
+        }
+        for (let index = indexes.length - 1; index > 0; index -= 1) {
+            state = (Math.imul(state, 1_664_525) + 1_013_904_223) >>> 0;
+            const swapIndex = state % (index + 1);
+            [indexes[index], indexes[swapIndex]] = [
+                indexes[swapIndex],
+                indexes[index],
+            ];
+        }
+    }
+    const ranks = [];
+    indexes.forEach((index, rank) => {
+        ranks[index] = rank;
+    });
+    return ranks;
+}
+function textTokens(text, unit, ignoreSpaces) {
     if (unit === "character") {
         const Segmenter = Intl.Segmenter;
         const parts = Segmenter
@@ -329,7 +448,7 @@ function textTokens(text, unit) {
             : Array.from(text);
         return parts.map((part) => ({
             text: part,
-            animated: !/^\s+$/u.test(part),
+            animated: !ignoreSpaces || !/^\s+$/u.test(part),
         }));
     }
     const Segmenter = Intl.Segmenter;
@@ -346,7 +465,7 @@ function textTokens(text, unit) {
     for (let index = 0; index < chunks.length; index += 1) {
         const chunk = chunks[index];
         if (/^\s+$/u.test(chunk.text)) {
-            tokens.push({ text: chunk.text, animated: false });
+            tokens.push({ text: chunk.text, animated: !ignoreSpaces });
         }
         else if (chunk.word) {
             tokens.push({ text: chunk.text, animated: true });
@@ -379,7 +498,8 @@ function renderTextNodes(node, animation, nextUnitIndex) {
     collectTextLeaves(node, textLeaves, { current: 0 });
     const text = textLeaves.map((leaf) => leaf.text).join("");
     const unit = animation.unit === "character" ? "character" : "word";
-    const tokenValues = textTokens(text, unit);
+    const ignoreSpaces = animation.unit === "character" ? motionTextIgnoreSpaces(animation) : true;
+    const tokenValues = textTokens(text, unit, ignoreSpaces);
     const tokens = [];
     let tokenOffset = 0;
     for (const token of tokenValues) {
@@ -455,6 +575,11 @@ function renderTextLeaf(leaf, tokens) {
             parts.push(text);
             continue;
         }
+        if (/^\s+$/u.test(token.text)) {
+            parts.push(text);
+            parts.push(_jsx("span", { "aria-hidden": "true", className: "agent-native-motion-text-unit agent-native-motion-text-space-unit", "data-agent-native-motion-text-unit": token.index }, `${token.index}-${start}-space`));
+            continue;
+        }
         parts.push(_jsx("span", { className: "agent-native-motion-text-unit", "data-agent-native-motion-text-unit": token.index, children: text }, `${token.index}-${start}`));
     }
     return parts;

package/dist/client/use-action.js

@@ -1,4 +1,5 @@
 import { hashKey, useQuery, useMutation, useQueryClient, } from "@tanstack/react-query";
+import { useContext } from "react";
 import { ACTION_BATCH_ACTION_NAME } from "../shared/action-batch.js";
 import { ACTION_BROWSER_PERSIST_ALLOW, ACTION_BROWSER_PERSIST_HEADER, } from "../shared/action-browser-persist.js";
 import { ACTION_CHANGE_MARKER_FAILED, ACTION_CHANGE_MARKER_HEADER, } from "../shared/action-change-marker-header.js";
@@ -6,6 +7,7 @@ import { SLOW_ACTION_RESPONSE_MS } from "../shared/analytics-events.js";
 import { ANALYTICS_CLIENT_PLATFORM_HEADER } from "../shared/analytics-platform.js";
 import { actionCircuitRemainingMs, actionErrorCode, actionErrorRetryAfterMs, actionErrorStatus, assertActionCircuitClosed, endsActionPolling, isActionCircuitOpenError, isTerminalActionError, recordActionFailure, resetActionFailureCircuit, resetActionFailureCircuits, } from "./action-failure-circuit.js";
 import { fetchActionGet } from "./action-get-batch.js";
+import { trustedActionQueryCacheBindingPendingContext } from "./action-query-cache-context.js";
 import { ACTION_RESOURCES_META_KEY, actionQueryAffectedByResources, } from "./action-query-scope.js";
 import { getAnalyticsClientPlatform } from "./analytics-platform.js";
 import { getOrCreateAnalyticsSessionId } from "./analytics-session.js";
@@ -867,8 +869,16 @@ function canBatchActionQueryFetch(query) {
 }
 export function useActionQuery(actionName, params, options) {
     const apiDisabled = Boolean(agentNativeApiDisabledReason());
-    const { refetchInterval, retry: callerRetry, queryKeyScope, resources, batchRefetches, ...restOptions } = options ?? {};
+    const { refetchInterval, retry: callerRetry, enabled: callerEnabled, queryKeyScope, resources, batchRefetches, ...restOptions } = options ?? {};
     const queryKey = ["action", actionName, params, ...(queryKeyScope ?? [])];
+    const trustedBindingPending = useContext(trustedActionQueryCacheBindingPendingContext);
+    const queryClient = useQueryClient();
+    const existingQuery = trustedBindingPending
+        ? queryClient.getQueryCache().find({ queryKey, exact: true })
+        : undefined;
+    const deferFetchUntilBound = trustedBindingPending &&
+        existingQuery?.state.fetchStatus !== "fetching" &&
+        existingQuery?.state.data === undefined;
     const circuitKey = () => hashKey(queryKey);
     return useQuery({
         queryKey,
@@ -935,6 +945,13 @@ export function useActionQuery(actionName, params, options) {
         },
         retryDelay: defaultActionQueryRetryDelay,
         ...restOptions,
+        enabled: (query) => {
+            if (deferFetchUntilBound)
+                return false;
+            return typeof callerEnabled === "function"
+                ? callerEnabled(query)
+                : callerEnabled !== false;
+        },
         ...(resources || batchRefetches === false
             ? {
                 meta: {

package/dist/collab/routes.d.ts

@@ -13,8 +13,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
     };
 }>>;
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/migrations.d.ts

@@ -3,6 +3,7 @@ type NitroPluginDef = (nitroApp: any) => void | Promise<void>;
 export declare function isDuplicateColumnError(err: unknown): boolean;
 /** True when the connected Postgres role cannot apply the migration. */
 export declare function isPermissionError(err: unknown): boolean;
+export declare function splitSqlStatements(sql: string): string[];
 export interface RunMigrationsOptions {
     runInServerlessRequest?: boolean;
     table: string;

package/dist/db/migrations.js

@@ -80,7 +80,7 @@ function isMissingRelationError(err) {
     const e = err;
     return (e?.code === "42P01" || /relation .* does not exist/i.test(e?.message ?? ""));
 }
-function splitSqlStatements(sql) {
+export function splitSqlStatements(sql) {
     const out = [];
     let buf = "";
     let i = 0;

package/dist/db/runtime-facts.d.ts

@@ -9,3 +9,10 @@ export declare function retryOnDdlRace<T>(fn: () => Promise<T>): Promise<T>;
  * client, so modules that mock `./client.js` keep working.
  */
 export declare function dbClientGeneration(): number;
+/**
+ * True while a store migration runs that the ledger will record once it
+ * resolves. Helpers that swallow failures elsewhere must rethrow here, or the
+ * ledger records a step that never happened and never retries it.
+ */
+export declare function isRecordingStoreMigration(): boolean;
+export declare function runRecordingStoreMigration<T>(run: () => Promise<T>): Promise<T>;

package/dist/db/runtime-facts.js

@@ -1,3 +1,4 @@
+import { getAsyncLocalStorageCtor } from "../shared/optional-node-builtins.js";
 /**
  * Dependency-free database runtime facts. Kept out of `./client.js` so the
  * store runner does not require every `vi.mock("../db/client.js")` to stub them.
@@ -39,3 +40,20 @@ export function dbClientGeneration() {
     const proc = globalThis.process;
     return proc?.__agentNativePgliteClientGeneration ?? 0;
 }
+const AsyncLocalStorageCtor = getAsyncLocalStorageCtor();
+const recordingStoreMigration = AsyncLocalStorageCtor
+    ? new AsyncLocalStorageCtor()
+    : undefined;
+/**
+ * True while a store migration runs that the ledger will record once it
+ * resolves. Helpers that swallow failures elsewhere must rethrow here, or the
+ * ledger records a step that never happened and never retries it.
+ */
+export function isRecordingStoreMigration() {
+    return recordingStoreMigration?.getStore() === true;
+}
+export function runRecordingStoreMigration(run) {
+    return recordingStoreMigration
+        ? recordingStoreMigration.run(true, run)
+        : run();
+}

package/dist/db/schema-catalog.js

@@ -6,7 +6,7 @@
  * has no `pg_dump`.
  */
 /** Tables whose rows are migration bookkeeping, dumped with their data. */
-const BOOKKEEPING_TABLE = /(?:^_.*migrations?$|_migrations$|^_an_store_migrations$)/;
+const BOOKKEEPING_TABLE = /^_[a-z0-9_]*migrations(?:_named)?$/;
 async function rows(exec, sql) {
     return (await exec.execute(sql)).rows;
 }
@@ -21,6 +21,9 @@ function literal(value) {
     }
     if (typeof value === "boolean")
         return value ? "TRUE" : "FALSE";
+    // Locale-formatted dates do not parse back; ISO 8601 does, in any time zone.
+    if (value instanceof Date)
+        return `'${value.toISOString()}'`;
     return `'${String(value).replace(/'/g, "''")}'`;
 }
 const COLUMNS_SQL = `

package/dist/db/store-ledger.test-helpers.d.ts

@@ -0,0 +1,5 @@
+export declare function isStoreLedgerStatement(sql: string): boolean;
+export declare function storeLedgerResult(sql: string): {
+    rows: Array<Record<string, unknown>>;
+    rowsAffected: number;
+} | undefined;

package/dist/db/store-ledger.test-helpers.js

@@ -0,0 +1,19 @@
+/**
+ * For specs that mock `getDbExec()` with a hand-written executor. Outside
+ * hosted runtimes a store records its migrations in `_an_store_migrations`
+ * (see `store-registry.ts`), so a strict mock sees those statements too.
+ * Answer them as an empty ledger: every store then applies its migrations
+ * against the mock once per executor, as it did before the ledger.
+ */
+const STORE_LEDGER_STATEMENT = /\b_an_store_migration(?:s|_lock)\b/;
+export function isStoreLedgerStatement(sql) {
+    return STORE_LEDGER_STATEMENT.test(sql);
+}
+export function storeLedgerResult(sql) {
+    if (!isStoreLedgerStatement(sql))
+        return undefined;
+    return {
+        rows: [],
+        rowsAffected: /^\s*(?:INSERT|UPDATE|DELETE)\b/i.test(sql) ? 1 : 0,
+    };
+}

package/dist/db/store-registry.d.ts

@@ -13,6 +13,7 @@
  * kept only for that.
  */
 import { type DbExec } from "./client.js";
+import { type MigrationEntry } from "./migrations.js";
 export declare const STORE_MIGRATIONS_TABLE = "_an_store_migrations";
 export interface StoreMigration {
     /** Stable, never renamed: the ledger records it. */
@@ -24,9 +25,37 @@ export interface StoreMigration {
     readonly kind?: "schema" | "data";
     readonly sql?: string | readonly string[];
     readonly run?: (exec: DbExec) => Promise<void>;
+    /**
+     * The versioned `runMigrations` entry this migration replaces. A database
+     * whose old bookkeeping table already records that entry gets a ledger row
+     * (`source = 'legacy'`) instead of running it again.
+     */
+    readonly legacy?: LegacyMigrationRef;
+}
+export interface LegacyMigrationRef {
+    /** The `runMigrations` table, e.g. `_chat_thread_schema_migrations`. */
+    readonly table: string;
+    readonly version: number;
+    /** Set for named entries, which were gated by name, not version. */
+    readonly name?: string;
+    /**
+     * Where the list ran on main. A release-only list (the default) keeps
+     * running only in the release step. A list that also ran at plugin boot
+     * runs everywhere: local runtimes import its history once, and hosted apps
+     * without release migrations keep running it through `runMigrations` and
+     * its old table, exactly as before.
+     */
+    readonly ranAtBoot?: boolean;
+    /** The original entry, for that hosted `runMigrations` path. */
+    readonly entry?: MigrationEntry;
 }
 export interface StoreDefinition {
     readonly id: string;
+    /**
+     * Stores whose migrations must run first at release, for a migration that
+     * reads or alters another store's tables. Registry order is otherwise by id.
+     */
+    readonly after?: readonly string[];
     /**
      * Never provision from a request, even for hosted apps that do not migrate
      * at release: the release step (or a versioned list) is the only creator.
@@ -58,6 +87,11 @@ export declare class SchemaNotMigratedError extends Error {
 export declare function schemaIsReleaseOwned(): boolean;
 /** Stable across bundlers; `run` bodies are not hashed because minifiers rewrite them. */
 export declare function migrationChecksum(migration: StoreMigration): string | null;
+/**
+ * Registry order with each store's `after` dependencies first. Fails on an
+ * unknown id or a cycle rather than guessing an order.
+ */
+export declare function orderStoresForRelease<T extends StoreDefinition>(stores: readonly T[]): T[];
 /**
  * Every registered store's migrations that the ledger does not list. The
  * release step calls this after applying, so a deploy whose ledger disagrees

package/dist/db/store-registry.generated.js

@@ -48,6 +48,10 @@ export const FRAMEWORK_STORES = [
         "automation_run_history",
         () => import("../jobs/run-history.js").then((m) => m.automationRunHistoryStore),
     ],
+    [
+        "automation_trigger_events",
+        () => import("../triggers/event-queue.js").then((m) => m.automationTriggerEventsStore),
+    ],
     [
         "automation_webhook_tokens",
         () => import("../triggers/webhook-store.js").then((m) => m.automationWebhookTokensStore),
@@ -56,6 +60,10 @@ export const FRAMEWORK_STORES = [
         "awaiting_inputs",
         () => import("../integrations/awaiting-input-store.js").then((m) => m.awaitingInputsStore),
     ],
+    [
+        "better_auth",
+        () => import("../server/better-auth-migrations.js").then((m) => m.betterAuthStore),
+    ],
     [
         "browser_sessions",
         () => import("../browser-sessions/store.js").then((m) => m.browserSessionsStore),
@@ -80,6 +88,10 @@ export const FRAMEWORK_STORES = [
         "computer_approvals",
         () => import("../integrations/computer-supervision-store.js").then((m) => m.computerApprovalsStore),
     ],
+    [
+        "context_xray",
+        () => import("../agent/context-xray/schema-store.js").then((m) => m.contextXrayStore),
+    ],
     [
         "conversation_scopes",
         () => import("../integrations/scope-store.js").then((m) => m.conversationScopesStore),
@@ -164,6 +176,7 @@ export const FRAMEWORK_STORES = [
         "observational_memory",
         () => import("../agent/observational-memory/store.js").then((m) => m.observationalMemoryStore),
     ],
+    ["org", () => import("../org/schema-store.js").then((m) => m.orgStore)],
     [
         "pending_tasks",
         () => import("../integrations/pending-tasks-store.js").then((m) => m.pendingTasksStore),