@adcp/sdk 5.25.0 → 6.0.0

package/dist/lib/server/decisioning/runtime/from-platform.d.ts

@@ -0,0 +1,510 @@
+/**
+ * Build an `AdcpServer` from a `DecisioningPlatform` impl.
+ *
+ * v6.0 alpha entry point. Translates the per-specialism platform interface
+ * into the framework's existing handler-style config and delegates to
+ * `createAdcpServer()`. This means every framework primitive — idempotency,
+ * RFC 9421 signing, governance, schema validation, state store, MCP/A2A
+ * wire mapping, sandbox boundary — applies unchanged. The new code is the
+ * adapter shim, not a forked runtime.
+ *
+ * **Adopter shape (unified hybrid):** each HITL-eligible tool is a single
+ * method. The method returns the wire success arm (sync fast path) OR
+ * `ctx.handoffToTask(fn)` to promote the call to a background task (HITL
+ * slow path). Adopters branch per-call; framework detects the `TaskHandoff`
+ * marker and dispatches accordingly:
+ *
+ *   - Sync path: framework awaits the return value in foreground; projects
+ *     it to the wire success arm. `throw new AdcpError(...)` projects to
+ *     the wire `adcp_error` envelope.
+ *   - HITL path: framework detects the `TaskHandoff` marker, allocates
+ *     `taskId`, returns the submitted envelope to the buyer immediately,
+ *     then runs the handoff function in background. The function's return
+ *     value becomes the task's terminal `result`; thrown `AdcpError` becomes
+ *     the terminal `error`.
+ *
+ * Generic thrown errors (`Error`, `TypeError`) fall through to the
+ * framework's `SERVICE_UNAVAILABLE` mapping.
+ *
+ * **Wired surface (6.0):** `SalesPlatform` (14 tools — 3 required core +
+ * 11 optional; unified hybrid on `create_media_buy` / `sync_creatives`),
+ * `CreativeBuilderPlatform` (build_creative / sync_creatives unified
+ * hybrid, optional preview_creative sync-only, optional refineCreative),
+ * `AudiencePlatform.syncAudiences`, `SignalsPlatform` (activate_signal,
+ * list_signals), `AccountStore` (reportUsage, getAccountFinancials),
+ * `ContentStandardsPlatform`, `CampaignGovernancePlatform`,
+ * `TenantRegistry` (multi-tenant health), `createPostgresTaskRegistry`,
+ * `tasks/get` wire handler, per-server + module-level `publishStatusChange`.
+ *
+ * **Still deferred (rc.1+):** MCP Resources subscription projection for
+ * `publishStatusChange`; `resolveAccount(undefined, { authInfo, toolName })`
+ * refactor for `provide_performance_feedback` / `list_creative_formats`
+ * no-account path in `'explicit'`-mode adopters (see `SalesPlatform` JSDoc).
+ *
+ * Status: Preview / 6.0. Not yet exported from the public `./server`
+ * subpath; reach in via `@adcp/sdk/server/decisioning/runtime` for
+ * spike experimentation only.
+ *
+ * @public
+ */
+import type { AdcpServer } from '../../adcp-server';
+import { type AdcpServerConfig, type HandlerContext } from '../../create-adcp-server';
+import type { DecisioningPlatform, RequiredPlatformsFor, RequiredCapabilitiesFor } from '../platform';
+import type { Account } from '../account';
+import { type CtxMetadataStore } from '../../ctx-metadata';
+import type { PgQueryable } from '../../postgres-task-store';
+import { type TaskRegistry, type TaskRecord } from './task-registry';
+import { type StatusChangeBus } from '../status-changes';
+import { type ComplyControllerConfig } from '../../../testing/comply-controller';
+/**
+ * Lifecycle observability hooks the v6 runtime fires at well-known points.
+ * Each callback is optional; throws are caught and logged via the framework
+ * logger so adopter telemetry mistakes never break dispatch.
+ *
+ * Reach for these to wire DataDog / Prometheus / OpenTelemetry / structured
+ * logging without baking any specific backend into the framework. For
+ * OpenTelemetry, the `@adcp/sdk/telemetry/otel` peer-dep adapter returns
+ * a pre-wired implementation with AdCP-aligned span / metric names.
+ *
+ * **What's instrumented today (v6.0):**
+ * - Task lifecycle (`onTaskCreate`, `onTaskTransition`) — fires from `dispatchHitl`
+ * - Webhook delivery (`onWebhookEmit`) — fires after each push-notification post
+ * - Status-change events (`onStatusChangePublish`) — wraps the per-server bus
+ * - Account resolution (`onAccountResolve`) — fires after every `resolve()` call
+ *
+ * **Coming in v6.1:**
+ * - Per-tool dispatch latency (`onDispatchStart` / `onDispatchEnd`) —
+ *   requires wrapping every handler entry point; lands when the per-handler
+ *   instrumentation pass goes through.
+ * - Idempotency replay rate (covered at the framework layer when v5 hooks land)
+ * - State-store reads (per-handler instrumentation)
+ *
+ * @public
+ */
+export interface DecisioningObservabilityHooks {
+    /**
+     * Fired after `accounts.resolve` (or `resolveAccountFromAuth`) returns.
+     * `resolved: false` means the resolver returned `null` — caller maps to
+     * `ACCOUNT_NOT_FOUND`. `fromAuth: true` indicates the auth-derived path
+     * (tools without an `account` field on the wire). `accountId` is the
+     * resolved tenant id when `resolved: true`, undefined otherwise — useful
+     * for dimensioning DD / Prometheus tag sets by tenant.
+     *
+     * **Cardinality warning:** if you forward `accountId` to a multi-tenant
+     * metric backend, pre-bucket or sample — high tenant counts will
+     * explode tag cardinality.
+     */
+    onAccountResolve?(info: {
+        tool: string;
+        durationMs: number;
+        resolved: boolean;
+        fromAuth: boolean;
+        accountId?: string;
+    }): void;
+    /**
+     * Fired when `dispatchHitl` allocates a new task in the registry.
+     * `durationMs` is the registry-create call latency (typically
+     * sub-millisecond for in-memory, single-digit ms for Postgres).
+     */
+    onTaskCreate?(info: {
+        tool: string;
+        taskId: string;
+        accountId: string;
+        durationMs: number;
+    }): void;
+    /**
+     * Fired when a task transitions to a terminal state (`completed`,
+     * `failed`, or `failed-write` when the registry write itself fails).
+     * `durationMs` is from create → terminal. `errorCode` is the structured
+     * error code for the failure cases — pre-bucketed for metric tags
+     * (matches `ErrorCode` enum + the framework-synthetic
+     * `'REGISTRY_WRITE_FAILED'` value).
+     */
+    onTaskTransition?(info: {
+        taskId: string;
+        tool: string;
+        accountId: string;
+        status: 'completed' | 'failed';
+        durationMs: number;
+        errorCode?: string;
+    }): void;
+    /**
+     * Fired after a push-notification webhook delivery attempt completes
+     * (success or all retries exhausted). Adopters wire to per-buyer
+     * deliverability dashboards.
+     *
+     * `errorCode` is a single bucketed value adopters tag metrics with
+     * (`'TIMEOUT'`, `'CONNECTION_REFUSED'`, `'HTTP_4XX'`, `'HTTP_5XX'`,
+     * `'SIGNATURE_FAILURE'`, `'UNKNOWN'` — derived from the underlying
+     * emitter error). `errorMessages` is the raw free-text error list for
+     * structured-log adopters; do NOT forward this to metrics tag values.
+     */
+    onWebhookEmit?(info: {
+        taskId: string;
+        tool: string;
+        status: string;
+        url: string;
+        success: boolean;
+        durationMs: number;
+        errorCode?: string;
+        errorMessages?: string[];
+    }): void;
+    /**
+     * Fired after each `publishStatusChange(...)` event (per-server bus +
+     * module-level singleton routes both go through the wrapped bus). Lets
+     * adopters meter event rates per resource type without subscribing.
+     */
+    onStatusChangePublish?(info: {
+        accountId: string;
+        resourceType: string;
+        resourceId: string;
+    }): void;
+}
+export interface CreateAdcpServerFromPlatformOptions extends Omit<AdcpServerConfig, 'resolveAccount' | 'capabilities' | 'name' | 'version'> {
+    name: string;
+    version: string;
+    /**
+     * Override the framework's task registry. Useful for tests that want to
+     * pre-seed task records or assert on them across multiple servers.
+     * Defaults to a fresh `createInMemoryTaskRegistry()` per server instance
+     * (gated by NODE_ENV — see `buildDefaultTaskRegistry`).
+     */
+    taskRegistry?: TaskRegistry;
+    /**
+     * Override the framework's status-change event bus for this server.
+     * Defaults to a fresh per-server `createInMemoryStatusChangeBus()` so
+     * tests get isolation without touching the module-level singleton from
+     * `publishStatusChange(...)`. Adopters who publish from non-handler code
+     * (webhook handlers, crons) typically use the module-level primitive
+     * — pass an explicit bus here only when you want a per-server channel.
+     */
+    statusChangeBus?: StatusChangeBus;
+    /**
+     * Lifecycle observability hooks. Adopters wire their telemetry backend
+     * (DataDog, Prometheus, OpenTelemetry, structured logger, etc.) by
+     * supplying any subset of the callbacks below. The framework calls them
+     * at well-known dispatch points; throws inside callbacks are caught and
+     * logged via `opts.logger.warn` — they never break dispatch.
+     *
+     * For an out-of-the-box OpenTelemetry binding, `@adcp/sdk/telemetry/otel`
+     * (peer-dep, opt-in) returns a pre-wired `DecisioningObservabilityHooks`
+     * object. Adopters using DataDog, Prometheus, or hand-rolled metrics
+     * implement the callbacks directly.
+     */
+    observability?: DecisioningObservabilityHooks;
+    /**
+     * Merge-seam collision behavior. When an adopter-supplied custom handler
+     * (e.g. `opts.mediaBuy.getMediaBuys`) collides with a platform-derived
+     * handler (e.g. `platform.sales.getMediaBuys`), the platform-derived one
+     * wins per-key and the adopter override is silently shadowed.
+     *
+     * Modes:
+     * - `'warn'` (default) — log a warning at every construction that hits a
+     *   collision. Migration signal without breaking running deployments.
+     * - `'log-once'` — log a warning the first time each `(domain, keys)`
+     *   collision is seen in the process; subsequent constructions with the
+     *   same shape stay silent. Right default for multi-tenant hosts (one
+     *   process, N `createAdcpServerFromPlatform` calls) and hot-reload dev
+     *   (server reconstructed every file change).
+     * - `'strict'` — throw `PlatformConfigError`. Recommended for CI / new
+     *   deployments where the v6 surface is the canonical source.
+     * - `'silent'` — skip the check. For adopters who deliberately use the
+     *   merge seam as an override (e.g., wrapping platform behavior with
+     *   logging in their custom handler).
+     */
+    mergeSeam?: MergeSeamMode;
+    /**
+     * Override the webhook emitter the framework uses to push HITL task
+     * completion to the buyer's `push_notification_config.url`. Default: when
+     * the host wired `webhooks` on the underlying `AdcpServerConfig`, use
+     * `ctx.emitWebhook` from the per-request HandlerContext (the framework
+     * binds `webhookEmitter.emit` to it). Pass an explicit emitter here when
+     * you want a dedicated webhook delivery path for task completions
+     * (different signing key, different retry policy, different fetch impl)
+     * separate from your other webhook emissions, or to inject a fake for
+     * tests without wiring full RFC 9421 signing.
+     *
+     * **Signing posture is your responsibility.** When adopters claim
+     * `signed-requests` capability, buyers expect RFC 9421-signed webhooks.
+     * The default emitter (bound to `serve({ webhooks })`) signs;
+     * a custom emitter passed here MUST either delegate to the same signed
+     * pipeline or sign itself. Set `unsigned: true` to acknowledge that this
+     * emitter intentionally bypasses signing — without that flag, an
+     * unsigned emitter wired in production would silently ship unsigned
+     * webhooks to buyers expecting signatures. Tests / dev paths set
+     * `unsigned: true`.
+     */
+    taskWebhookEmitter?: {
+        emit: NonNullable<HandlerContext<Account>['emitWebhook']>;
+        /**
+         * Set to `true` to acknowledge this emitter does NOT sign the webhook
+         * payload (RFC 9421). Required for tests and development; production
+         * deployments with `signed-requests` claimed should leave this
+         * unset / `false` and rely on the framework's signing path.
+         */
+        unsigned?: boolean;
+    };
+    /**
+     * `comply_test_controller` adapter set. When supplied, the framework
+     * registers the wire tool automatically by composing `createComplyController`
+     * (`@adcp/sdk/testing`) with the adopter's adapters and calling
+     * `controller.register(server)` after platform handlers wire up.
+     *
+     * Adopter declares the scenarios they support — `seed: { product, … }`,
+     * `force: { creative_status, … }`, `simulate: { delivery, … }`. The
+     * framework auto-derives `capabilities.compliance_testing.scenarios`
+     * from which adapters are present, projecting the discovery field to
+     * `get_adcp_capabilities` so conformance harnesses see what's
+     * supported.
+     *
+     * **Sandbox gating.** `complyTest.sandboxGate(input)` is the per-request
+     * gate; tools/list visibility is controlled by whether you supply
+     * `complyTest` at all. Production agents typically gate registration
+     * itself on `process.env.ADCP_SANDBOX === '1'` or wrap construction in
+     * an environment check; the helper logs a loud warning if registered
+     * without a gate AND without an env-flag escape (matches the standalone
+     * `createComplyController` warning behavior).
+     *
+     * **Capability-vs-adapter consistency.** If
+     * `capabilities.compliance_testing` is declared but `complyTest` is
+     * omitted, construction throws `PlatformConfigError` — the framework
+     * refuses to project a discovery block the runtime can't honor.
+     *
+     * @public
+     */
+    complyTest?: ComplyControllerConfig;
+    /**
+     * Single-pool shortcut: pass a `pg.Pool` (or any `PgQueryable`) and the
+     * framework wires `idempotency` + `ctxMetadata` + `taskRegistry`
+     * internally with sensible defaults. One connection, three concerns.
+     *
+     * Adopters who pass any of `idempotency` / `ctxMetadata` / `taskRegistry`
+     * explicitly keep override priority — the explicit values win, and the
+     * pool fills only the unset ones.
+     *
+     * Run `getAllAdcpMigrations()` once per database to create the three
+     * required tables (idempotency cache, ctx-metadata cache, task registry).
+     *
+     * @example
+     * ```ts
+     * import { Pool } from 'pg';
+     * import {
+     *   createAdcpServerFromPlatform,
+     *   getAllAdcpMigrations,
+     * } from '@adcp/sdk/server';
+     *
+     * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+     * await pool.query(getAllAdcpMigrations());
+     *
+     * const server = createAdcpServerFromPlatform(myPlatform, {
+     *   name: 'my-agent',
+     *   version: '1.0.0',
+     *   pool,                                // wires all three persistence stores
+     * });
+     * ```
+     *
+     * **Memory-only deployment:** omit `pool` entirely. Framework defaults to
+     * in-memory backends for all three (fine for dev / single-process; not
+     * suitable for cluster).
+     */
+    pool?: PgQueryable;
+    /**
+     * Ctx-metadata store. Wire to enable the v6.1 `ctx_metadata` round-trip
+     * cache: publishers attach opaque platform-specific blobs to any returned
+     * resource (`{ product_id, ctx_metadata: { gam: {...} } }`); the framework
+     * persists by `(account.id, kind, id)` and threads back into
+     * `ctx.ctxMetadata` on subsequent calls referencing the same ID.
+     *
+     * Memory backend (`memoryCtxMetadataStore()`) for dev / single-process.
+     * Postgres (`pgCtxMetadataStore(pool)`) for cluster — silent ctx_metadata
+     * loss after rolling restart on memory backend produces "package not
+     * found" errors that look like publisher bugs and run for weeks.
+     *
+     * @example
+     * ```ts
+     * import { Pool } from 'pg';
+     * import {
+     *   createAdcpServerFromPlatform,
+     *   createCtxMetadataStore,
+     *   pgCtxMetadataStore,
+     *   getCtxMetadataMigration,
+     * } from '@adcp/sdk/server';
+     *
+     * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+     * await pool.query(getCtxMetadataMigration());
+     *
+     * const ctxMetadata = createCtxMetadataStore({ backend: pgCtxMetadataStore(pool) });
+     *
+     * createAdcpServerFromPlatform(myPlatform, {
+     *   name: 'My Adapter',
+     *   version: '1.0.0',
+     *   ctxMetadata,
+     * });
+     * ```
+     *
+     * @see docs/proposals/decisioning-platform-v6-1-ctx-metadata.md
+     */
+    ctxMetadata?: CtxMetadataStore;
+    /**
+     * Allow `push_notification_config.url` to point at loopback / private-IP
+     * destinations. Default is `false` — the framework's request-ingest
+     * validator rejects loopback (`localhost`, `127.0.0.0/8`, `::1`),
+     * RFC 1918 / CGNAT / link-local ranges, and IPv4-mapped IPv6 forms
+     * targeting any of those, since accepting them at production webhook
+     * endpoints is a SSRF / cloud-metadata exfiltration path.
+     *
+     * Set `true` for sandbox / local-testing deployments where
+     * adopter-controlled receivers (storyboard webhook receivers, pytest
+     * httptest fixtures) bind to `127.0.0.1:<ephemeral>`. The flag bypasses
+     * ONLY the private-range branch — malformed-URL, non-http(s) scheme,
+     * and the `http://` reject (separately gated by NODE_ENV / the
+     * `ADCP_DECISIONING_ALLOW_HTTP_WEBHOOKS` env) all still fire.
+     *
+     * Adopters typically scope this themselves on `NODE_ENV !== 'production'`
+     * or a sandbox env flag — the framework doesn't auto-enable it because
+     * the safe default is "reject private destinations." When the flag is
+     * `true` AND `NODE_ENV` is unset / `'production'`, the framework emits
+     * a one-shot console.warn at construction calling out the relaxation.
+     */
+    allowPrivateWebhookUrls?: boolean;
+    /**
+     * Auto-fire a completion webhook on the sync-success arm of mutating
+     * tools when the request supplied `push_notification_config.url`.
+     * Default is `true` — buyers passing the URL expect notification
+     * regardless of whether the seller routed the call sync vs HITL, and
+     * v5 adopters routinely wired this manually inside every handler.
+     * The framework now does it for them.
+     *
+     * Webhook payload mirrors the HITL completion shape: top-level
+     * `task_type` (the wire tool name), `status: 'completed'`, and
+     * `result` carrying the projected sync response. `task_id` is
+     * synthesized per call (sync responses don't allocate a registry
+     * task); buyers correlate via the resource IDs (`media_buy_id`,
+     * `creative_id`, etc.) on `result`.
+     *
+     * Same `SPEC_WEBHOOK_TASK_TYPES` gate as the HITL path: tools outside
+     * the closed wire enum don't emit (adopters use `publishStatusChange`
+     * for those). Sync auto-emit and the HITL path share the same
+     * `emitWebhook` plumbing — host-wired signing, redelivery, and
+     * observability hooks all apply uniformly.
+     *
+     * Set `false` to suppress the auto-emit for adopters who emit
+     * webhooks manually inside their handlers (idempotency duplication
+     * concern) or for transitional deployments that don't yet have the
+     * webhook receiver path stood up.
+     */
+    autoEmitCompletionWebhooks?: boolean;
+}
+/**
+ * Adcp server returned by `createAdcpServerFromPlatform`. Adds task-state
+ * accessors on top of the standard `AdcpServer` so test harnesses (and the
+ * forthcoming `tasks/get` wire handler) can inspect lifecycle.
+ */
+export interface DecisioningAdcpServer extends AdcpServer {
+    /**
+     * Read the current lifecycle state for a HITL task. Returns `null` if the
+     * `taskId` is unknown OR (when `expectedAccountId` is supplied) the
+     * task's owning account doesn't match.
+     *
+     * **Multi-tenant isolation: pass `expectedAccountId` whenever the caller
+     * has a buyer-derived account in scope.** Adopters wrapping this method
+     * in a `tasks/get` wire handler MUST pass `ctx.account.id` to scope reads
+     * — without it, any caller with a known `task_id` reads any tenant's
+     * task lifecycle, including its `result` and `error` payloads. The
+     * unscoped form (single-arg) is for ops / test harnesses that hold no
+     * buyer account in scope.
+     *
+     * Async to accommodate storage-backed task registries
+     * (`createPostgresTaskRegistry`); the in-memory impl resolves synchronously.
+     */
+    getTaskState<TResult = unknown>(taskId: string, expectedAccountId?: string): Promise<TaskRecord<TResult> | null>;
+    /**
+     * Await any in-flight background completion for `taskId` (HITL handoff
+     * function still running). Resolves immediately if the task is terminal
+     * or has no registered background. Used by tests + the `tasks/get` wire
+     * path for deterministic settlement.
+     */
+    awaitTask(taskId: string): Promise<void>;
+    /**
+     * Per-server status-change bus. Delegates to the same internal bus the
+     * framework uses for MCP Resources subscription projection.
+     *
+     * Use `server.statusChange.publish(...)` in tests to push events scoped
+     * to this specific server instance — avoids contaminating sibling servers
+     * that share the module-level `activeBus` when running multiple servers
+     * in the same process. Production webhook/cron code that does not hold a
+     * server reference keeps calling the module-level `publishStatusChange(...)`.
+     *
+     * **Projection wiring contract** (rc.1): when the MCP Resources subscription
+     * projection commit lands, the projector MUST fan-in from BOTH this
+     * per-server bus AND the module-level `activeBus`. Anchoring the subscriber
+     * to only one source silently makes the other call site inert in production
+     * — adopters who scope to `server.statusChange.publish(...)` for tenant
+     * isolation must still reach buyer-facing subscriptions, and webhook/cron
+     * code calling module-level `publishStatusChange(...)` must too.
+     */
+    statusChange: StatusChangeBus;
+}
+export declare function createAdcpServerFromPlatform<P extends DecisioningPlatform<any, any>>(platform: P & RequiredPlatformsFor<P['capabilities']['specialisms'][number]> & RequiredCapabilitiesFor<P['capabilities']['specialisms'][number]>, opts: CreateAdcpServerFromPlatformOptions): DecisioningAdcpServer;
+/**
+ * Merge adopter-supplied custom handlers with platform-derived handlers.
+ * Platform-derived wins per-key when both define the same handler; adopter
+ * handlers fill any gaps. Returns `undefined` when neither side has any
+ * handlers (so the framework knows the domain is unrouted and can omit it
+ * from `tools/list`).
+ *
+ * Used to bridge the gap between v6 specialism interfaces (which model the
+ * stable v1.0 surface) and adopter codebases that need to dispatch
+ * tools the platform shape doesn't cover yet (getMediaBuys,
+ * listCreativeFormats, providePerformanceFeedback, reportUsage,
+ * sync_event_sources, log_event, content-standards CRUD, etc.).
+ *
+ * **Collision detection.** When a custom-supplied handler would be
+ * shadowed by a platform-derived one (i.e., the framework added native
+ * coverage for a tool the adopter previously filled via the merge seam),
+ * the resolver logs a warning by default. Tells adopters to migrate the
+ * custom logic into the platform method. Adopters who genuinely want
+ * the custom logic to win can pass `mergeSeam: 'silent'` to skip the
+ * warning, `'strict'` to throw a `PlatformConfigError`, or `'log-once'`
+ * to suppress duplicate warnings across multiple server constructions
+ * in the same process (multi-tenant deployments, hot-reload dev).
+ */
+type MergeSeamMode = 'warn' | 'log-once' | 'silent' | 'strict';
+/**
+ * Build the default in-memory task registry, gated by NODE_ENV.
+ *
+ * The in-memory registry loses task state on process restart — fine for
+ * tests and local dev, NOT fine for production. Gate via allowlist:
+ * `NODE_ENV` must be `'test'` or `'development'`, OR the operator must
+ * explicitly opt in via `ADCP_DECISIONING_ALLOW_INMEMORY_TASKS=1`.
+ *
+ * Pattern follows `feedback_node_env_allowlist.md`: never compare
+ * `=== 'production'` (production may unset NODE_ENV entirely); always
+ * allowlist the safe modes.
+ */
+/**
+ * Combined DDL for all framework persistence tables: idempotency cache,
+ * ctx-metadata cache, and decisioning task registry. Run once per database
+ * during deployment / boot. Idempotent — safe to re-run.
+ *
+ * Use with the `pool` shortcut on `createAdcpServerFromPlatform`:
+ *
+ * ```ts
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * await pool.query(getAllAdcpMigrations());
+ *
+ * createAdcpServerFromPlatform(myPlatform, {
+ *   name: '...', version: '...',
+ *   pool,
+ * });
+ * ```
+ *
+ * Adopters who don't use the `pool` shortcut should call the per-store
+ * migration helpers (`getIdempotencyMigration`, `getCtxMetadataMigration`,
+ * `getDecisioningTaskRegistryMigration`) only for the stores they wire.
+ *
+ * @public
+ */
+export declare function getAllAdcpMigrations(): string;
+export {};
+//# sourceMappingURL=from-platform.d.ts.map

package/dist/lib/server/decisioning/runtime/from-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-platform.d.ts","sourceRoot":"","sources":["../../../../../src/lib/server/decisioning/runtime/from-platform.ts"],"names":[],"mappings":"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"}