@agent-native/core 0.164.4 → 0.164.12

package/dist/coding-tools/sandbox/executions-store.d.ts

@@ -84,6 +84,7 @@ export declare const SANDBOX_EXECUTION_DEFAULT_MAX_ATTEMPTS = 2;
  * the caller's `maxOutputChars`) is applied first; this bounds even that.
  */
 export declare const SANDBOX_EXECUTION_MAX_STORED_OUTPUT_CHARS = 200000;
+export declare function ensureTable(): Promise<void>;
 /** Test-only: forget the memoized init so a fresh in-memory DB re-creates. */
 export declare function resetSandboxExecutionsStoreForTests(): void;
 /** Enqueue a new execution row in `queued` state. */

package/dist/coding-tools/sandbox/executions-store.js

@@ -40,7 +40,7 @@ export const SANDBOX_EXECUTION_DEFAULT_MAX_ATTEMPTS = 2;
 export const SANDBOX_EXECUTION_MAX_STORED_OUTPUT_CHARS = 200_000;
 const TABLE = "sandbox_executions";
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = _doEnsureTable().catch((err) => {
             // Don't cache the rejection — let the next caller retry a fresh init.

package/dist/collab/awareness-store.d.ts

@@ -14,6 +14,7 @@
  * state hasn't changed; expired rows are purged opportunistically.
  */
 import type { AwarenessEntry } from "./awareness.js";
+export declare function ensureTable(): Promise<void>;
 /**
  * Mirror a client's awareness state to SQL. Throttled: unchanged state is
  * rewritten at most every {@link WRITE_THROTTLE_MS} (to refresh last_seen).

package/dist/collab/awareness-store.js

@@ -22,7 +22,7 @@ const WRITE_THROTTLE_MS = 2_000;
 /** Minimum interval between opportunistic purges per document. */
 const PURGE_INTERVAL_MS = 30_000;
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/storage.d.ts

@@ -4,6 +4,7 @@
  * Uses a framework-level `_collab_docs` table (TEXT columns with base64
  * encoding for binary Yjs state) that works across SQLite and Postgres.
  */
+export declare function ensureTable(): Promise<void>;
 export interface YDocStateRecord {
     state: Uint8Array;
     version: number;

package/dist/collab/storage.js

@@ -33,7 +33,7 @@ async function executeWithSqliteRetry(client, statement) {
         }
     }
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/client.js

@@ -1,3 +1,4 @@
+import path from "path";
 /**
  * Central database client abstraction.
  *
@@ -8,7 +9,7 @@
  * (dynamic import) so this module can be loaded in any runtime (Node.js,
  * Cloudflare Workers, edge) without failing on missing native deps.
  */
-import path from "path";
+import { isMigrationAuthorizedRuntime } from "./migration-runtime.js";
 import { beginDatabaseOperation, recordDatabaseRetry, } from "./request-telemetry.js";
 const recyclingPostgresPools = new WeakSet();
 const loggedNeonPools = new WeakSet();
@@ -803,9 +804,8 @@ export function isSchemaMutationStatement(statement) {
  * is the only supported production opt-in.
  */
 export function assertSchemaMutationAllowed(statement) {
-    const migrationRuntime = globalThis.__AGENT_NATIVE_MIGRATION_RUNTIME__ === true;
     if (isProductionServerlessFunctionRuntime() &&
-        !migrationRuntime &&
+        !isMigrationAuthorizedRuntime() &&
         isSchemaMutationStatement(statement)) {
         throw new Error("Schema mutation attempted in a production serverless request. Run migrations in the release job instead.");
     }

package/dist/db/ddl-guard.js

@@ -29,6 +29,7 @@
  * behaviour there.
  */
 import { getDbExec, isPostgres, isProductionServerlessFunctionRuntime, } from "./client.js";
+import { isMigrationAuthorizedRuntime } from "./migration-runtime.js";
 const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
  * Skip on-demand schema DDL entirely. For deployments that run real migrations,
@@ -45,6 +46,13 @@ const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
  * down the DDL path this flag exists to avoid.
  */
 function schemaEnsureDisabled() {
+    // The release runner is the deployment that OWNS schema creation, so it is the
+    // one caller that must never be skipped. Without this, the skip below applies
+    // to `migrate:production` too — the Netlify build environment also sets
+    // `NETLIFY=true` — and the release step reports success having created
+    // nothing.
+    if (isMigrationAuthorizedRuntime())
+        return false;
     if (isProductionServerlessFunctionRuntime())
         return true;
     const raw = process.env.AGENT_NATIVE_SKIP_ENSURE_TABLES?.trim();

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

@@ -0,0 +1,23 @@
+/**
+ * Migration duty: the process-local claim that the current call is allowed to
+ * create or alter schema.
+ *
+ * Its own module, and deliberately dependency-free, because both `./client.js`
+ * and `./ddl-guard.js` need to read it. Putting the reader on `client.js` would
+ * mean every `vi.mock("../db/client.js")` in the codebase has to stub one more
+ * export to keep `ensureTable()` working — the exact coupling `ddl-guard.ts`
+ * was split out to avoid.
+ */
+/**
+ * A runtime that is ALLOWED to migrate: release scripts, scheduled jobs, and
+ * durable background workers, which are off the request path and may take as
+ * long as they need. Claimed with {@link withMigrationRuntime}.
+ */
+export declare function isMigrationAuthorizedRuntime(): boolean;
+/**
+ * Run an explicit release-time migration job with migration duty enabled.
+ *
+ * The flag is process-local and restored even when the job fails, so a build
+ * step can opt in without creating a permanent escape hatch for request code.
+ */
+export declare function withMigrationRuntime<T>(run: () => Promise<T>): Promise<T>;

package/dist/db/migration-runtime.js

@@ -0,0 +1,41 @@
+/**
+ * Migration duty: the process-local claim that the current call is allowed to
+ * create or alter schema.
+ *
+ * Its own module, and deliberately dependency-free, because both `./client.js`
+ * and `./ddl-guard.js` need to read it. Putting the reader on `client.js` would
+ * mean every `vi.mock("../db/client.js")` in the codebase has to stub one more
+ * export to keep `ensureTable()` working — the exact coupling `ddl-guard.ts`
+ * was split out to avoid.
+ */
+/**
+ * A runtime that is ALLOWED to migrate: release scripts, scheduled jobs, and
+ * durable background workers, which are off the request path and may take as
+ * long as they need. Claimed with {@link withMigrationRuntime}.
+ */
+export function isMigrationAuthorizedRuntime() {
+    return (globalThis
+        .__AGENT_NATIVE_MIGRATION_RUNTIME__ === true);
+}
+/**
+ * Run an explicit release-time migration job with migration duty enabled.
+ *
+ * The flag is process-local and restored even when the job fails, so a build
+ * step can opt in without creating a permanent escape hatch for request code.
+ */
+export async function withMigrationRuntime(run) {
+    const runtime = globalThis;
+    const previous = runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__;
+    runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__ = true;
+    try {
+        return await run();
+    }
+    finally {
+        if (previous === undefined) {
+            delete runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__;
+        }
+        else {
+            runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__ = previous;
+        }
+    }
+}

package/dist/db/migrations.d.ts

@@ -97,6 +97,5 @@ export interface MigrationEntry {
  * The flag is process-local and restored even when the job fails, so a build
  * step can opt in without creating a permanent escape hatch for request code.
  */
-export declare function withMigrationRuntime<T>(run: () => Promise<T>): Promise<T>;
+export { withMigrationRuntime } from "./migration-runtime.js";
 export declare function runMigrations(migrations: Array<MigrationEntry>, options: RunMigrationsOptions): NitroPluginDef;
-export {};

package/dist/db/migrations.js

@@ -1,4 +1,5 @@
 import { getDbExec, createDbExec, isPostgres, getDialect, getMigrationDatabaseUrl, getCloudflareD1Binding, retrySqliteBusy, } from "./client.js";
+import { isMigrationAuthorizedRuntime } from "./migration-runtime.js";
 // ---------------------------------------------------------------------------
 // Shared direct-endpoint exec across concurrent migration runners per boot.
 //
@@ -252,36 +253,13 @@ function appMigratesAtRelease() {
     const raw = process.env.AGENT_NATIVE_RELEASE_MIGRATIONS?.trim();
     return !!raw && ["1", "true", "yes", "on"].includes(raw.toLowerCase());
 }
-/**
- * A runtime that is ALLOWED to migrate: release scripts, scheduled jobs, and
- * durable background workers, which are off the request path and may take as
- * long as they need. Claimed with {@link withMigrationRuntime}.
- */
-function isMigrationAuthorizedRuntime() {
-    return (globalThis.__AGENT_NATIVE_MIGRATION_RUNTIME__ === true);
-}
 /**
  * Run an explicit release-time migration job with migration duty enabled.
  *
  * The flag is process-local and restored even when the job fails, so a build
  * step can opt in without creating a permanent escape hatch for request code.
  */
-export async function withMigrationRuntime(run) {
-    const runtime = globalThis;
-    const previous = runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__;
-    runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__ = true;
-    try {
-        return await run();
-    }
-    finally {
-        if (previous === undefined) {
-            delete runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__;
-        }
-        else {
-            runtime.__AGENT_NATIVE_MIGRATION_RUNTIME__ = previous;
-        }
-    }
-}
+export { withMigrationRuntime } from "./migration-runtime.js";
 export function runMigrations(migrations, options) {
     const table = options?.table;
     if (!table ||

package/dist/email-catalog/log.d.ts

@@ -5,6 +5,7 @@
  * to report per-email send counts and last-sent without depending on the
  * provider's activity retention window.
  */
+export declare function ensureTable(): Promise<void>;
 export interface RecordEmailSendArgs {
     orgId?: string | null;
     templateId?: string;

package/dist/email-catalog/log.js

@@ -10,7 +10,7 @@ import { getDbExec, isPostgres } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { getRequestOrgId } from "../server/request-context.js";
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const { EMAIL_LOG_CREATE_SQL, EMAIL_LOG_ORG_APP_INDEX_SQL, EMAIL_LOG_TEMPLATE_INDEX_SQL, } = await import("./schema.js");

package/dist/guards/index.d.ts

@@ -14,6 +14,7 @@ export type { DbToolScopingOptions } from "./db-tool-scoping.js";
 export { scanExplicitCollabAccess } from "./explicit-collab-access.js";
 export { scanDrizzlePush } from "./no-drizzle-push.js";
 export { scanEmptyMigrations } from "./no-empty-migrations.js";
+export { scanReleaseSchemaCoverage } from "./release-schema-complete.js";
 export type { EmptyMigrationsSourceOptions } from "./no-empty-migrations.js";
 export { analyzeEmptyMigrationsSource, shouldScanEmptyMigrationsFile, } from "./no-empty-migrations.js";
 export { scanEnvCredentials } from "./no-env-credentials.js";

package/dist/guards/index.js

@@ -13,6 +13,7 @@ export { scanDbToolScoping } from "./db-tool-scoping.js";
 export { scanExplicitCollabAccess } from "./explicit-collab-access.js";
 export { scanDrizzlePush } from "./no-drizzle-push.js";
 export { scanEmptyMigrations } from "./no-empty-migrations.js";
+export { scanReleaseSchemaCoverage } from "./release-schema-complete.js";
 export { analyzeEmptyMigrationsSource, shouldScanEmptyMigrationsFile, } from "./no-empty-migrations.js";
 export { scanEnvCredentials } from "./no-env-credentials.js";
 export { scanEnvMutation } from "./no-env-mutation.js";

package/dist/guards/release-schema-complete.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Every store that defines schema through `ensureTableExists()` must be listed
+ * in `server/release-schema.ts`.
+ *
+ * A store's `ensureTable()` is the only definition of its tables — there is no
+ * second copy in a migration list. Production serverless can never run one
+ * (`schemaEnsureDisabled()` reports every table present so a cold start skips
+ * ~390 probes), so a store missing from the release list has no path to
+ * creation on a hosted deploy at all. Nothing fails at deploy time; the first
+ * symptom is `relation "..." does not exist` from a user request, long after
+ * the commit that caused it.
+ *
+ * That is not hypothetical. `settings`, `application_state`, `app_secrets` and
+ * `resources` were absent from the release path for twelve days, and published
+ * sites came up with an empty database while the deploy reported success.
+ */
+import type { GuardResult, GuardScanOptions } from "./types.js";
+export interface ReleaseSchemaScanOptions extends GuardScanOptions {
+    /** Defaults to `<root>/packages/core`. */
+    corePackageDir?: string;
+}
+export declare function scanReleaseSchemaCoverage(options: ReleaseSchemaScanOptions): GuardResult;

package/dist/guards/release-schema-complete.js

@@ -0,0 +1,144 @@
+/**
+ * Every store that defines schema through `ensureTableExists()` must be listed
+ * in `server/release-schema.ts`.
+ *
+ * A store's `ensureTable()` is the only definition of its tables — there is no
+ * second copy in a migration list. Production serverless can never run one
+ * (`schemaEnsureDisabled()` reports every table present so a cold start skips
+ * ~390 probes), so a store missing from the release list has no path to
+ * creation on a hosted deploy at all. Nothing fails at deploy time; the first
+ * symptom is `relation "..." does not exist` from a user request, long after
+ * the commit that caused it.
+ *
+ * That is not hypothetical. `settings`, `application_state`, `app_secrets` and
+ * `resources` were absent from the release path for twelve days, and published
+ * sites came up with an empty database while the deploy reported success.
+ */
+import path from "node:path";
+import { readFileSafe, relPosix, walk } from "./scan-utils.js";
+/**
+ * What counts as "this module creates a table". `ensureTableExists` is the
+ * intended helper, but a store that executes its DDL through the raw client
+ * creates schema just as much, and needs the release pass just as much. Missing
+ * that second form is how `extensions/slots/store.ts` stayed invisible to the
+ * first version of this guard.
+ *
+ * Keyed on EXECUTING the DDL, not on containing it. A `schema.ts` that exports
+ * `CREATE TABLE` strings and a migration list that stores them both mention the
+ * SQL without ever running it: the first is executed by its own store, which is
+ * on the list, and the second is applied by `runMigrations`.
+ */
+const ENSURE_TABLE_RE = /\bensureTableExists\s*\(/;
+const EXECUTES_RE = /\.execute\s*\(/;
+const CREATE_TABLE_RE = /\bCREATE\s+TABLE\b/i;
+/**
+ * DDL that lives in another module, the way `extensions/slots` keeps its SQL in
+ * `slots/schema.ts`. Keyed on the `_CREATE_SQL` / `_TABLE_SQL` / `_INDEX_SQL`
+ * naming rather than on any executed constant, so a plain
+ * `execute(DB_PRESSURE_SQL)` SELECT is not mistaken for schema.
+ */
+const DDL_CONST_RE = /\b[A-Z][A-Z0-9_]*_(?:CREATE|TABLE|INDEX)_SQL(?:_[A-Z0-9]+)?\b/;
+/**
+ * Whether this module CREATES tables, in any of the three shapes the codebase
+ * actually uses. Deliberately NOT keyed on the name of the executed expression:
+ * stores run their DDL from a local `createSql` or `ddl` variable as often as
+ * from a named constant, so requiring a recognisable name would let the
+ * commonest shape of all walk past the guard.
+ */
+const definesSchema = (code) => ENSURE_TABLE_RE.test(code) ||
+    (EXECUTES_RE.test(code) &&
+        (CREATE_TABLE_RE.test(code) || DDL_CONST_RE.test(code)));
+const ALLOW_MARKER_RE = /guard:allow-unreleased-schema\s*[—-]\s*\S/;
+const SOURCE_EXTENSIONS = /\.(?:ts|tsx|mts|cts)$/i;
+const TEST_FILE = /\.(?:spec|test)\.(?:ts|tsx|mts|cts)$/i;
+/**
+ * The two halves of the release path. `release-schema.ts` runs the stores' own
+ * ensure functions; `release-migrations.ts` runs the versioned migration lists
+ * and a few schema runners of its own (better-auth). A module reached by either
+ * one is created at release, so both count as coverage.
+ */
+const RELEASE_LIST = "src/server/release-schema.ts";
+const RELEASE_MIGRATIONS = "src/server/release-migrations.ts";
+const DDL_GUARD = "src/db/ddl-guard.ts";
+/** The migration runner executes migration-list DDL; `runMigrations` owns it. */
+const MIGRATION_RUNNER = "src/db/migrations.ts";
+/** Guards describe this rule in prose; they never own schema. */
+const GUARDS_DIR = "src/guards/";
+/**
+ * Blank out comments so a file that only NAMES `ensureTableExists` — this guard,
+ * a doc block, a changelog note — is not reported as defining schema.
+ */
+function stripComments(source) {
+    return source
+        .replace(/\/\*[\s\S]*?\*\//g, " ")
+        .replace(/(^|[^:])\/\/[^\n]*/g, "$1 ");
+}
+/**
+ * Import specifiers in `release-schema.ts`, resolved to repo-relative paths so
+ * they can be compared against the files that actually call `ensureTableExists`.
+ */
+function coveredModules(coreDir, sources) {
+    const covered = new Set();
+    // Static `from "..."` and dynamic `import("...")`; the list uses the latter.
+    const importRe = /(?:from\s+|import\s*\(\s*)"([^"]+)"/g;
+    for (const match of sources.join("\n").matchAll(importRe)) {
+        const spec = match[1];
+        if (!spec.startsWith("."))
+            continue;
+        const fromDir = path.join(coreDir, "src", "server");
+        const resolved = path.resolve(fromDir, spec).replace(/\.js$/, ".ts");
+        covered.add(relPosix(coreDir, resolved));
+    }
+    return covered;
+}
+export function scanReleaseSchemaCoverage(options) {
+    const coreDir = options.corePackageDir ?? path.join(options.root, "packages", "core");
+    const findings = [];
+    const listSource = readFileSafe(path.join(coreDir, RELEASE_LIST));
+    if (listSource === null) {
+        // Not "nothing to check" — the list this guard exists to audit is gone.
+        findings.push({
+            file: RELEASE_LIST,
+            line: 1,
+            message: "release-schema.ts is missing; every framework table would stop being created at release time.",
+        });
+        return { name: "release-schema-complete", findings };
+    }
+    const covered = coveredModules(coreDir, [
+        listSource,
+        readFileSafe(path.join(coreDir, RELEASE_MIGRATIONS)) ?? "",
+    ]);
+    const srcDir = path.join(coreDir, "src");
+    for (const file of walk(srcDir)) {
+        if (!SOURCE_EXTENSIONS.test(file) || TEST_FILE.test(file))
+            continue;
+        const rel = relPosix(coreDir, file);
+        if (rel === RELEASE_LIST || rel === RELEASE_MIGRATIONS)
+            continue;
+        if (rel === DDL_GUARD)
+            continue;
+        if (rel === MIGRATION_RUNNER)
+            continue;
+        if (rel.startsWith(GUARDS_DIR))
+            continue;
+        const source = readFileSafe(file);
+        if (source === null)
+            continue;
+        const code = stripComments(source);
+        if (!definesSchema(code))
+            continue;
+        if (covered.has(rel))
+            continue;
+        if (ALLOW_MARKER_RE.test(source))
+            continue;
+        const lines = code.split("\n");
+        const line = lines.findIndex((text) => definesSchema(text)) + 1;
+        findings.push({
+            file: rel,
+            line: line > 0 ? line : 1,
+            message: "creates tables but is not imported by src/server/release-schema.ts, so they are never created on a hosted deploy.",
+        });
+    }
+    findings.sort((a, b) => a.file.localeCompare(b.file));
+    return { name: "release-schema-complete", findings };
+}

package/dist/integrations/a2a-continuations-store.d.ts

@@ -1,5 +1,6 @@
 import type { A2AArtifactIdentity } from "../a2a/artifact-response.js";
 import type { IncomingMessage, PlatformRunProgressRef } from "./types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function ensureA2AContinuationsTable(): Promise<void>;
 export type A2AContinuationStatus = "pending" | "processing" | "delivering" | "completed" | "failed";
 export type A2ATerminalDeliveryKind = "success" | "failure";

package/dist/integrations/a2a-continuations-store.js

@@ -42,7 +42,7 @@ function buildCreateSql() {
   )
 `;
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/awaiting-input-store.d.ts

@@ -1,5 +1,6 @@
 /** Channel-thread clarification windows are deliberately short-lived. */
 export declare const INTEGRATION_AWAITING_INPUT_TTL_MS: number;
+export declare function ensureTable(): Promise<void>;
 /**
  * Open (or refresh) the bounded reply window after an integration explicitly
  * asks the originating Slack user a question. The workspace-qualified external

package/dist/integrations/awaiting-input-store.js

@@ -3,7 +3,7 @@ import { ensureTableExists } from "../db/ddl-guard.js";
 let initPromise;
 /** Channel-thread clarification windows are deliberately short-lived. */
 export const INTEGRATION_AWAITING_INPUT_TTL_MS = 24 * 60 * 60 * 1000;
-async function ensureTable() {
+export async function ensureTable() {
     if (!initPromise) {
         initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/config-store.d.ts

@@ -1,3 +1,4 @@
+export declare function ensureTable(): Promise<void>;
 export declare function integrationConfigWriteEpoch(): number;
 export interface IntegrationConfig {
     platform: string;

package/dist/integrations/config-store.js

@@ -1,7 +1,7 @@
 import { getDbExec, isPostgres, intType } from "../db/client.js";
 import { ensureTableExists } from "../db/ddl-guard.js";
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/controls-store.d.ts

@@ -16,6 +16,7 @@ export interface IntegrationControl {
     status: "pending" | "claimed" | "expired";
     expiresAt: number;
 }
+export declare function ensureTable(): Promise<void>;
 export declare function _resetIntegrationControlsStoreForTests(): void;
 export declare function createIntegrationControl(input: {
     action: IntegrationControlAction;

package/dist/integrations/controls-store.js

@@ -3,7 +3,7 @@ import { getDbExec, intType, isPostgres } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 import { isDuplicateColumnError } from "../db/migrations.js";
 let initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!initPromise) {
         initPromise = (async () => {
             const sql = `CREATE TABLE IF NOT EXISTS integration_controls (

package/dist/integrations/identity-links-store.d.ts

@@ -12,6 +12,7 @@ export interface IntegrationIdentityLink {
     createdAt: number;
     updatedAt: number;
 }
+export declare function ensureTable(): Promise<void>;
 /** Persist a verified mapping and fail closed if it changes identity later. */
 export declare function upsertVerifiedIntegrationIdentity(input: {
     platform: string;

package/dist/integrations/identity-links-store.js

@@ -32,7 +32,7 @@ const INDEXES = [
       ON ${TABLE}(org_id, user_email)`,
     ],
 ];
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/installations-store.d.ts

@@ -83,6 +83,7 @@ export interface IntegrationInstallationUpdate {
     lastHealthyAt?: number | null;
     tokenExpiresAt?: number | null;
 }
+export declare function ensureTable(): Promise<void>;
 /**
  * Create or refresh a managed install. Re-installs may rotate tokens inside
  * the same owner/org scope, but cannot silently move an existing provider

package/dist/integrations/installations-store.js

@@ -61,7 +61,7 @@ const INDEXES = [
         `CREATE INDEX IF NOT EXISTS idx_integration_installations_org ON ${TABLE}(org_id, updated_at)`,
     ],
 ];
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-commands-store.d.ts

@@ -1,4 +1,5 @@
 import type { ComputerCommandEnvelope, ComputerOperationClass, RemoteCommand, RemoteCommandKind } from "./remote-types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function isRemoteCommandKind(value: unknown): value is RemoteCommandKind;
 export declare function enqueueRemoteCommand(input: {
     deviceId: string;

package/dist/integrations/remote-commands-store.js

@@ -16,7 +16,7 @@ const REMOTE_COMMAND_KINDS = [
     "status",
 ];
 const TERMINAL_STATUSES = new Set(["completed", "failed"]);
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-devices-store.d.ts

@@ -1,4 +1,5 @@
 import type { PublicRemoteDevice, RemoteComputerCapabilities, RemoteDevice, RemoteDeviceMetadata, RemoteExecutionCapabilities } from "./remote-types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function toPublicRemoteDevice(device: RemoteDevice): PublicRemoteDevice;
 export declare function getRemoteComputerCapabilities(device: Pick<RemoteDevice, "metadata">): RemoteComputerCapabilities | null;
 export declare function getRemoteExecutionCapabilities(device: Pick<RemoteDevice, "metadata">): RemoteExecutionCapabilities | null;

package/dist/integrations/remote-devices-store.js

@@ -1,7 +1,7 @@
 import { getDbExec, intType, isPostgres, retryOnDdlRace, } from "../db/client.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
 let _initPromise;
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-push-store.d.ts

@@ -1,4 +1,5 @@
 import type { PublicRemotePushRegistration, RemotePushNotification, RemotePushRegistration } from "./remote-types.js";
+export declare function ensureTables(): Promise<void>;
 export declare function toPublicRemotePushRegistration(registration: RemotePushRegistration): PublicRemotePushRegistration;
 export declare function upsertRemotePushRegistration(input: {
     ownerEmail: string;

package/dist/integrations/remote-push-store.js

@@ -43,7 +43,7 @@ function buildCreateNotificationsSql() {
   )
 `;
 }
-async function ensureTables() {
+export async function ensureTables() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/remote-run-events-store.d.ts

@@ -1,4 +1,5 @@
 import type { RemoteLiveViewEvent, RemoteRunEvent } from "./remote-types.js";
+export declare function ensureTable(): Promise<void>;
 export declare function insertRemoteRunEvents(input: {
     deviceId: string;
     remoteRunId: string;

package/dist/integrations/remote-run-events-store.js

@@ -18,7 +18,7 @@ function buildCreateSql() {
   )
 `;
 }
-async function ensureTable() {
+export async function ensureTable() {
     if (!_initPromise) {
         _initPromise = (async () => {
             const client = getDbExec();

package/dist/integrations/scope-store.d.ts

@@ -42,6 +42,7 @@ export interface SaveIntegrationScopeInput extends IntegrationScopeKey {
     defaultModel?: string | null;
     policy?: Partial<IntegrationScopePolicy>;
 }
+export declare function ensureTable(): Promise<void>;
 /** A stable, non-secret subject key suitable for a scope budget. */
 export declare function integrationScopeSubjectKey(key: IntegrationScopeKey): string;
 export declare function getIntegrationScope(keyInput: IntegrationScopeKey, accessInput: IntegrationScopeAccess): Promise<IntegrationScope | null>;