@intx/db 0.3.0 → 0.4.0

package/README.md

@@ -37,6 +37,17 @@ typed values; downstream code uses those values without
 re-casting. See `CONVENTIONS.md` for the project-wide rule against
 cast-at-callsite in DB consumers.
 
+Connections created by `createDB` set PostgreSQL's `statement_timeout` to
+60,000 milliseconds. Override it with `statementTimeoutMs` in `DBConfig`
+(a positive integer up to 2,147,483,647 milliseconds). The Hub and the
+`bin/` database scripts read this override from `DB_STATEMENT_TIMEOUT_MS`.
+
+PostgreSQL cancels statements that exceed the deadline, including time
+waiting for locks. An uncaught timeout rolls back the enclosing transaction.
+This bounds individual statements once they reach PostgreSQL; pool waits,
+network stalls, and time between statements in an open transaction remain
+outside that deadline. Migration clients use their own connection settings.
+
 ## Model catalog
 
 The `model`, `model_provider`, `model_offering`, and `model_pricing`

package/dist/approval-store.d.ts

@@ -39,6 +39,13 @@ export declare function createApprovalStore(db: DBHandle): {
      * uses. Returns null when no row carries the id.
      */
     findById(id: string, tx?: DBExecutor): Promise<ParsedApproval | null>;
+    /**
+     * List a run's approvals, newest first, scoped by `tenantId` so one
+     * tenant's approvals never leak into another's view. Serves the run
+     * approvals list route; callers apply whatever status/scope predicate they
+     * need over the result.
+     */
+    listByRunId(tenantId: string, runId: string, tx?: DBExecutor): Promise<ParsedApproval[]>;
     /**
      * Conditionally resolve a pending approval. The `WHERE status = 'pending'`
      * guard makes resolution terminal at the database: the first caller to

package/dist/approval-store.js

@@ -55,6 +55,19 @@ export function createApprovalStore(db) {
             });
             return row === undefined ? null : parseApprovalRow(row);
         },
+        /**
+         * List a run's approvals, newest first, scoped by `tenantId` so one
+         * tenant's approvals never leak into another's view. Serves the run
+         * approvals list route; callers apply whatever status/scope predicate they
+         * need over the result.
+         */
+        async listByRunId(tenantId, runId, tx) {
+            const rows = await (tx ?? db).query.approval.findMany({
+                where: and(eq(approval.tenantId, tenantId), eq(approval.runId, runId)),
+                orderBy: (a, { desc }) => desc(a.createdAt),
+            });
+            return rows.map(parseApprovalRow);
+        },
         /**
          * Conditionally resolve a pending approval. The `WHERE status = 'pending'`
          * guard makes resolution terminal at the database: the first caller to

package/dist/backfill-principal-keys.d.ts

@@ -0,0 +1,9 @@
+import type { DB } from "./client.js";
+import type { PrincipalKeyStore } from "./principal-key-store.js";
+export type BackfillPrincipalKeysReport = {
+    /** Principals that were keyless and received a fresh active key. */
+    keysGenerated: number;
+    /** Principals that already held an active key and were left untouched. */
+    alreadyKeyed: number;
+};
+export declare function backfillPrincipalKeys(db: DB["db"], principalKeyStore: PrincipalKeyStore): Promise<BackfillPrincipalKeysReport>;

package/dist/backfill-principal-keys.js

@@ -0,0 +1,51 @@
+// Backfill per-principal signing keys onto the principals that predate the
+// feature.
+//
+// Minting a key lives only in the principal-creation owner, so every principal
+// CREATED after that landed already has an active key. This one-shot pass keys
+// the pre-existing population so the whole non-agent principal set matches the
+// invariant "every non-agent principal has an active key".
+//
+// Scope is every `user` and `workflow` principal REGARDLESS of status, not just
+// active ones. A status flip (e.g. an invite moving from `invited` to `active`)
+// reuses the same principal row and does not re-mint, so an active-only pass
+// would leave a pre-existing `invited`/`suspended` principal keyless and turn it
+// into a keyless ACTIVE principal the moment it is activated. `agent` is a
+// legacy/inert kind that is never keyed at creation either, so it is skipped to
+// keep the populations consistent.
+//
+// Idempotent: a principal that already holds an active key is skipped, so the
+// pass is safe to re-run or resume after a partial failure. Each principal is
+// keyed in its own autocommit, so a partial failure leaves the earlier
+// principals keyed. Safe to run against a LIVE hub -- nothing reads principal
+// keys yet, the hub only mints for newly-created principals (disjoint from this
+// pass's pre-existing set), and the `principal_key` active-key unique index
+// blocks a double active key.
+import { and, eq, inArray } from "drizzle-orm";
+import { principal } from "./schema/principals.js";
+import { principalKey } from "./schema/principal-keys.js";
+const BACKFILLED_KINDS = ["user", "workflow"];
+export async function backfillPrincipalKeys(db, principalKeyStore) {
+    // The left join is scoped to the active key, so `activeKeyId` is null exactly
+    // when the principal has no active key -- a principal holding only a retired
+    // key counts as keyless and is re-keyed. The active-key unique index makes at
+    // most one active row per principal, so each principal appears once.
+    const rows = await db
+        .select({ principalId: principal.id, activeKeyId: principalKey.id })
+        .from(principal)
+        .leftJoin(principalKey, and(eq(principalKey.principalId, principal.id), eq(principalKey.status, "active")))
+        .where(inArray(principal.kind, [...BACKFILLED_KINDS]));
+    const report = {
+        keysGenerated: 0,
+        alreadyKeyed: 0,
+    };
+    for (const row of rows) {
+        if (row.activeKeyId !== null) {
+            report.alreadyKeyed += 1;
+            continue;
+        }
+        await principalKeyStore.generate(row.principalId);
+        report.keysGenerated += 1;
+    }
+    return report;
+}

package/dist/client.d.ts

@@ -1,12 +1,37 @@
+import type { ExtractTablesWithRelations } from "drizzle-orm";
+import type { PgDatabase, PgQueryResultHKT } from "drizzle-orm/pg-core";
 import * as schema from "./schema/index.js";
+/**
+ * A drizzle database over the hub schema, typed against the driver-agnostic
+ * `PgDatabase` base rather than a single driver. `createDB` builds one over
+ * postgres-js; a caller can equally build one over pglite -- `drizzle(handle,
+ * { schema })` from `drizzle-orm/pglite`, with the schema re-exported from
+ * `@intx/db/schema` -- and pass it to the store factories. The required
+ * `$client` keeps a bare `PgTransaction` unassignable (a transaction carries no
+ * `$client`), so a parameter typed against this still rejects a tx where only a
+ * top-level database belongs.
+ */
+export type AnyPgDatabase = PgDatabase<PgQueryResultHKT, typeof schema, ExtractTablesWithRelations<typeof schema>> & {
+    $client: unknown;
+};
+/**
+ * The hub database handle: the database itself, plus `transaction` and
+ * `close`. `createDB` returns the postgres-js instantiation, but the handle is
+ * typed against `AnyPgDatabase` so the stores accept any pg driver -- a
+ * caller-built pglite database included.
+ */
+export interface DB {
+    db: AnyPgDatabase;
+    transaction: AnyPgDatabase["transaction"];
+    close: () => Promise<void>;
+}
 export declare function createDB(raw: unknown): {
     db: import("drizzle-orm/postgres-js").PostgresJsDatabase<typeof schema> & {
         $client: import("postgres").Sql<{}>;
     };
-    transaction: <T>(transaction: (tx: import("drizzle-orm/pg-core").PgTransaction<import("drizzle-orm/postgres-js").PostgresJsQueryResultHKT, typeof schema, import("drizzle-orm").ExtractTablesWithRelations<typeof schema>>) => Promise<T>, config?: import("drizzle-orm/pg-core").PgTransactionConfig) => Promise<T>;
+    transaction: <T>(transaction: (tx: import("drizzle-orm/pg-core").PgTransaction<import("drizzle-orm/postgres-js").PostgresJsQueryResultHKT, typeof schema, ExtractTablesWithRelations<typeof schema>>) => Promise<T>, config?: import("drizzle-orm/pg-core").PgTransactionConfig) => Promise<T>;
     close: () => Promise<void>;
 };
-export type DB = ReturnType<typeof createDB>;
 /**
  * A handle that can execute queries: either the top-level `db` or a
  * transaction handle passed into a `db.transaction` callback. Store methods

package/dist/client.js

@@ -16,3 +16,9 @@ export function createDB(raw) {
         close: () => sql.end(),
     };
 }
+// `createDB` returns the concrete postgres-js handle so its own callers keep
+// the driver's precise result types (e.g. a typed `db.execute`). This assures
+// at the definition site that the concrete handle still satisfies `DB`, the
+// driver-agnostic contract the stores consume.
+const _createDBReturnsDB = createDB;
+void _createDBReturnsDB;

package/dist/config.d.ts

@@ -6,6 +6,7 @@ export declare const DBConfig: import("arktype/internal/variants/object.ts").Obj
     database: string;
     ssl?: boolean;
     max?: number;
+    statementTimeoutMs?: number;
     schema?: string;
 }, {}>;
 export type DBConfig = typeof DBConfig.infer;

package/dist/config.js

@@ -7,6 +7,8 @@ export const DBConfig = type({
     database: "string",
     "ssl?": "boolean",
     "max?": "number.integer > 0",
+    // PostgreSQL statement deadline in milliseconds. Defaults to 60 seconds.
+    "statementTimeoutMs?": "0 < number.integer <= 2147483647",
     // Postgres schema name. When set, the connection's `search_path` is
     // pinned to this schema and migrations apply into it. This is the
     // mechanism the integration-test harness uses to give each spawned

package/dist/connection.js

@@ -13,6 +13,7 @@ export function createConnection(config) {
         ...(config.ssl !== undefined && { ssl: config.ssl }),
         connection: {
             TimeZone: "UTC",
+            statement_timeout: config.statementTimeoutMs ?? 60_000,
             ...(config.schema !== undefined && {
                 // Pin the connection's search_path so unqualified table
                 // references resolve to the caller's schema. The migration

package/dist/credential-resolution.d.ts

@@ -1,5 +1,5 @@
 import type { CredentialBinding, CredentialCipher } from "@intx/types";
-import type { CredentialDelivery } from "@intx/types/sidecar";
+import type { CredentialDelivery, CredentialMaterialEntry } from "@intx/types/sidecar";
 import type { DB } from "./client.js";
 /**
  * Thrown by `resolveCredentialRequirement` when more than one credential
@@ -11,6 +11,18 @@ import type { DB } from "./client.js";
 export declare class AmbiguousCredentialError extends Error {
     constructor(message: string);
 }
+/**
+ * Thrown when a referenced credential is not a tenant-owned credential the given
+ * tenant can use -- it does not exist, is not reachable in the tenant's ancestor
+ * chain, or is principal-owned. A distinct type so a caller can map a client's
+ * bad credential reference to a 4xx (a launch-blocking configuration error),
+ * separate from the infrastructure faults the resolvers otherwise surface.
+ */
+export declare class CredentialUnauthorizedError extends Error {
+    readonly credentialId: string;
+    readonly tenantId: string;
+    constructor(credentialId: string, tenantId: string);
+}
 /**
  * Resolve a credential USABLE by the launching tenant purely through ownership:
  * it exists, is reachable in the tenant's ancestor chain, and is tenant-owned
@@ -32,8 +44,8 @@ export declare function resolveTenantOwnedCredentialById(db: DB["db"], tenantId:
     providerId: string;
     tenantId: string;
     status: "active" | "error" | "expired" | "revoked";
-    description: string | null;
     principalId: string | null;
+    description: string | null;
     scopes: string[] | null;
     metadata: unknown;
     oauthClientId: string | null;
@@ -41,6 +53,43 @@ export declare function resolveTenantOwnedCredentialById(db: DB["db"], tenantId:
     secret: string;
     refreshSecret: string | null;
 } | null>;
+/**
+ * Resolve a set of inference-source credentialIds into the credential material
+ * delivered on a run's unified credential-material cell. An inference source
+ * references its credential by id only; for each DISTINCT id this resolves the
+ * secret under the SAME tenant-ownership authority `buildSource` uses -- the
+ * credential must exist, be reachable in the tenant's ancestor chain, and be
+ * tenant-owned (`principalId IS NULL`) -- then decrypts it at the single point of
+ * use. `providerKey`/`origin` come from the credential's own provider row
+ * (`provider.plugin` / `provider.apiBaseUrl`), so the material describes the
+ * credential itself, independent of any caller-supplied source fields.
+ *
+ * Fails CLOSED, by throwing, on the first credentialId that is unresolved, not
+ * tenant-owned, references a missing provider, or whose provider has no API
+ * origin to pin -- a secret is never dropped nor delivered without an origin. The
+ * single resolver for every inference source credentialId -> material, shared by
+ * the deploy composition (top-level + inline body sources) and any other caller
+ * that must materialize inference credentials for the cell.
+ */
+export declare function resolveInferenceMaterials(db: DB["db"], tenantId: string, credentialIds: Iterable<string>, credentialCipher: CredentialCipher): Promise<CredentialMaterialEntry[]>;
+/**
+ * Re-resolve the CURRENT material for a set of already-authorized credentialIds,
+ * for the reconnect resync. Unlike `resolveInferenceMaterials`, a credential
+ * that no longer exists or is `revoked` is DROPPED (omitted) rather than
+ * throwing: the resync reflects credential lifecycle, so a dead id is simply
+ * absent from the reconciled delivery and the child evicts it.
+ *
+ * A credential that IS alive but whose material cannot be resolved (its provider
+ * vanished or has no API base URL) is NOT a lifecycle removal, so it throws --
+ * the caller aborts the whole reconcile rather than delivering a partial set
+ * paired with a spurious revoke. A rotated secret is picked up because the row's
+ * current secret is decrypted here.
+ *
+ * Ids are looked up by primary key (globally unique) and come from the
+ * deployment's own persisted delivery, so no re-authorization is performed --
+ * this reflects lifecycle only.
+ */
+export declare function reresolveCurrentMaterials(db: DB["db"], credentialIds: Iterable<string>, credentialCipher: CredentialCipher): Promise<CredentialMaterialEntry[]>;
 /**
  * Resolves a provider by name, walking up the tenant hierarchy.
  * Returns the first match (child shadows parent).
@@ -89,8 +138,8 @@ export declare function resolveCredentialByName(db: DB["db"], tenantId: string,
     providerId: string;
     tenantId: string;
     status: "active" | "error" | "expired" | "revoked";
-    description: string | null;
     principalId: string | null;
+    description: string | null;
     scopes: string[] | null;
     metadata: unknown;
     oauthClientId: string | null;
@@ -111,8 +160,8 @@ export declare function resolveCredentialById(db: DB["db"], tenantId: string, cr
     providerId: string;
     tenantId: string;
     status: "active" | "error" | "expired" | "revoked";
-    description: string | null;
     principalId: string | null;
+    description: string | null;
     scopes: string[] | null;
     metadata: unknown;
     oauthClientId: string | null;
@@ -142,8 +191,8 @@ export declare function resolveCredentialRequirement(db: DB["db"], tenantId: str
         providerId: string;
         tenantId: string;
         status: "active" | "error" | "expired" | "revoked";
-        description: string | null;
         principalId: string | null;
+        description: string | null;
         scopes: string[] | null;
         metadata: unknown;
         oauthClientId: string | null;

package/dist/credential-resolution.js

@@ -18,6 +18,23 @@ export class AmbiguousCredentialError extends Error {
         this.name = "AmbiguousCredentialError";
     }
 }
+/**
+ * Thrown when a referenced credential is not a tenant-owned credential the given
+ * tenant can use -- it does not exist, is not reachable in the tenant's ancestor
+ * chain, or is principal-owned. A distinct type so a caller can map a client's
+ * bad credential reference to a 4xx (a launch-blocking configuration error),
+ * separate from the infrastructure faults the resolvers otherwise surface.
+ */
+export class CredentialUnauthorizedError extends Error {
+    credentialId;
+    tenantId;
+    constructor(credentialId, tenantId) {
+        super(`credential ${credentialId} is not a tenant-owned credential usable by tenant ${tenantId}`);
+        this.name = "CredentialUnauthorizedError";
+        this.credentialId = credentialId;
+        this.tenantId = tenantId;
+    }
+}
 /**
  * Resolve a credential USABLE by the launching tenant purely through ownership:
  * it exists, is reachable in the tenant's ancestor chain, and is tenant-owned
@@ -34,6 +51,98 @@ export async function resolveTenantOwnedCredentialById(db, tenantId, credentialI
     const row = await resolveCredentialById(db, tenantId, credentialId);
     return row !== null && row.principalId === null ? row : null;
 }
+/**
+ * Resolve a set of inference-source credentialIds into the credential material
+ * delivered on a run's unified credential-material cell. An inference source
+ * references its credential by id only; for each DISTINCT id this resolves the
+ * secret under the SAME tenant-ownership authority `buildSource` uses -- the
+ * credential must exist, be reachable in the tenant's ancestor chain, and be
+ * tenant-owned (`principalId IS NULL`) -- then decrypts it at the single point of
+ * use. `providerKey`/`origin` come from the credential's own provider row
+ * (`provider.plugin` / `provider.apiBaseUrl`), so the material describes the
+ * credential itself, independent of any caller-supplied source fields.
+ *
+ * Fails CLOSED, by throwing, on the first credentialId that is unresolved, not
+ * tenant-owned, references a missing provider, or whose provider has no API
+ * origin to pin -- a secret is never dropped nor delivered without an origin. The
+ * single resolver for every inference source credentialId -> material, shared by
+ * the deploy composition (top-level + inline body sources) and any other caller
+ * that must materialize inference credentials for the cell.
+ */
+export async function resolveInferenceMaterials(db, tenantId, credentialIds, credentialCipher) {
+    const materials = new Map();
+    for (const credentialId of credentialIds) {
+        if (materials.has(credentialId))
+            continue;
+        const row = await resolveTenantOwnedCredentialById(db, tenantId, credentialId);
+        if (row === null) {
+            throw new CredentialUnauthorizedError(credentialId, tenantId);
+        }
+        const providerRow = await db.query.provider.findFirst({
+            where: eq(provider.id, row.providerId),
+        });
+        if (providerRow === undefined) {
+            throw new Error(`credential ${credentialId} references provider ${row.providerId}, which does not exist`);
+        }
+        if (providerRow.apiBaseUrl === null || providerRow.apiBaseUrl === "") {
+            throw new Error(`provider ${providerRow.name} backing credential ${credentialId} has no API base URL; cannot pin an origin for its material`);
+        }
+        materials.set(credentialId, {
+            credentialId: row.id,
+            providerKey: providerRow.plugin,
+            origin: providerRow.apiBaseUrl,
+            secret: await credentialCipher.decrypt(row.secret, credentialAad(row.id, "secret")),
+        });
+    }
+    return [...materials.values()];
+}
+/**
+ * Re-resolve the CURRENT material for a set of already-authorized credentialIds,
+ * for the reconnect resync. Unlike `resolveInferenceMaterials`, a credential
+ * that no longer exists or is `revoked` is DROPPED (omitted) rather than
+ * throwing: the resync reflects credential lifecycle, so a dead id is simply
+ * absent from the reconciled delivery and the child evicts it.
+ *
+ * A credential that IS alive but whose material cannot be resolved (its provider
+ * vanished or has no API base URL) is NOT a lifecycle removal, so it throws --
+ * the caller aborts the whole reconcile rather than delivering a partial set
+ * paired with a spurious revoke. A rotated secret is picked up because the row's
+ * current secret is decrypted here.
+ *
+ * Ids are looked up by primary key (globally unique) and come from the
+ * deployment's own persisted delivery, so no re-authorization is performed --
+ * this reflects lifecycle only.
+ */
+export async function reresolveCurrentMaterials(db, credentialIds, credentialCipher) {
+    const materials = new Map();
+    for (const credentialId of credentialIds) {
+        if (materials.has(credentialId))
+            continue;
+        const row = await db.query.credential.findFirst({
+            where: eq(credential.id, credentialId),
+        });
+        if (row === undefined)
+            continue; // deleted -> drop
+        if (row.status === "revoked")
+            continue; // revoked -> drop
+        const providerRow = await db.query.provider.findFirst({
+            where: eq(provider.id, row.providerId),
+        });
+        if (providerRow === undefined) {
+            throw new Error(`credential ${credentialId} references provider ${row.providerId}, which does not exist`);
+        }
+        if (providerRow.apiBaseUrl === null || providerRow.apiBaseUrl === "") {
+            throw new Error(`provider ${providerRow.name} backing credential ${credentialId} has no API base URL; cannot pin an origin for its material`);
+        }
+        materials.set(credentialId, {
+            credentialId: row.id,
+            providerKey: providerRow.plugin,
+            origin: providerRow.apiBaseUrl,
+            secret: await credentialCipher.decrypt(row.secret, credentialAad(row.id, "secret")),
+        });
+    }
+    return [...materials.values()];
+}
 /**
  * Resolves a provider by name, walking up the tenant hierarchy.
  * Returns the first match (child shadows parent).

package/dist/index.d.ts

@@ -1,22 +1,28 @@
-export { createDB, type DB, type DBExecutor } from "./client.js";
+export { createDB, type AnyPgDatabase, type DB, type DBExecutor, } from "./client.js";
 export { pgErrorCode, PG_UNIQUE_VIOLATION, PG_FOREIGN_KEY_VIOLATION, } from "./pg-error.js";
 export type { DBConfig } from "./config.js";
 export { runMigrations, dropSchema } from "./migrate.js";
 export { rekeyCredentialSecrets, type RekeyReport, } from "./rekey-credential-secrets.js";
+export { backfillPrincipalKeys, type BackfillPrincipalKeysReport, } from "./backfill-principal-keys.js";
 export { createGrantStore } from "./grant-store.js";
+export { createPrincipalStore, type PrincipalStore } from "./principal-store.js";
+export { createPrincipalKeyStore, type CreatePrincipalKeyStoreDeps, type PrincipalKeyStore, } from "./principal-key-store.js";
+export { lookupLocalPrincipalSigner } from "./signer-identity.js";
+export { resolveSenderKey, resolveFrameSenderKey, auditSenderKeys, type SenderKeyResolution, type SenderKeyAuditReport, } from "./sender-key-resolver.js";
 export { createApprovalStore, type ApprovalStore, type ResolveApprovalArgs, } from "./approval-store.js";
 export { createSignalCorrelationStore, type SignalCorrelationStore, } from "./signal-correlation-store.js";
 export { createWorkflowRunStore, type WorkflowRunStore, } from "./workflow-run-store.js";
 export { createWorkflowRunLaunchSpecStore, type WorkflowRunLaunchSpecStore, } from "./workflow-run-launch-spec-store.js";
 export { createWorkflowRunDispatchStore, WorkflowRunDispatchPayloadConflictError, type AcknowledgeWorkflowRunDispatchArgs, type ClaimWorkflowRunDispatchArgs, type EnqueueWorkflowRunDispatchArgs, type EnqueueWorkflowRunDispatchResult, type EnqueueWorkflowSignalDispatchArgs, type RetryWorkflowRunDispatchArgs, type WorkflowRunDispatchStore, } from "./workflow-run-dispatch-store.js";
-export { createSidecarAllocationStore, type BeginSidecarReleaseArgs, type BeginSidecarReplacementArgs, type BindInitialSidecarArgs, type BindReplacementSidecarArgs, type ClaimSidecarAllocationArgs, type CreatePendingSidecarAllocationArgs, type FailSidecarAllocationArgs, type MarkSidecarAllocatedArgs, type MarkSidecarConnectionLostArgs, type MarkSidecarConnectionReadyArgs, type MarkSidecarReleasedArgs, type ParkSidecarReconciliationPolicy, type ScheduleSidecarAllocationRetryArgs, type SidecarAllocation, type SidecarAllocationStore, } from "./sidecar-allocation-store.js";
+export { createSidecarAllocationStore, type BeginSidecarReleaseArgs, type BeginSidecarReplacementArgs, type BindInitialSidecarArgs, type BindReplacementSidecarArgs, type CreateAdoptedSidecarAllocationArgs, type ClaimSidecarAllocationArgs, type CreatePendingSidecarAllocationArgs, type FailSidecarAllocationArgs, type MarkSidecarAllocatedArgs, type MarkSidecarConnectionLostArgs, type MarkSidecarConnectionReadyArgs, type MarkSidecarDestroyFailedArgs, type MarkSidecarReleasedArgs, type ParkSidecarReconciliationPolicy, type ScheduleSidecarAllocationRetryArgs, type SidecarAllocation, type SidecarAllocationStore, } from "./sidecar-allocation-store.js";
+export { createWorkflowProbeStore, type BindWorkflowProbeSidecarArgs, type CreateWorkflowProbeArgs, type WorkflowProbe, type WorkflowProbeStore, } from "./workflow-probe-store.js";
 export { createWorkflowDefinitionStore, loadFrozenGrantSnapshot, resolveDefinitionIdForAsset, type WorkflowDefinitionRollbackResult, type WorkflowDefinitionSelector, } from "./workflow-definition-store.js";
-export { getAncestorChain, getDescendantTenants } from "./tenant-hierarchy.js";
+export { getAncestorChain, getDescendantTenants, resolveTenantSidecarCapabilityPolicies, } from "./tenant-hierarchy.js";
 export { resolveActivePrice, type ModelPricingRow } from "./pricing.js";
-export { resolveProviderByName, resolveOAuthClient, resolveCredentialByName, resolveCredentialById, resolveCredentialRequirement, resolveTenantOwnedCredentialById, AmbiguousCredentialError, buildCredentialDelivery, } from "./credential-resolution.js";
+export { resolveProviderByName, resolveOAuthClient, resolveCredentialByName, resolveCredentialById, resolveCredentialRequirement, resolveTenantOwnedCredentialById, resolveInferenceMaterials, reresolveCurrentMaterials, AmbiguousCredentialError, CredentialUnauthorizedError, buildCredentialDelivery, } from "./credential-resolution.js";
 export type { BuildCredentialDeliveryResult, CredentialDeliveryFailure, } from "./credential-resolution.js";
 export { resolveAssetByName, resolveAssetById, listAssetsForTenant, type AssetRow, type AssetWithOrigin, } from "./asset-resolution.js";
 export { listVisibleModels, listVisibleProviders, listVisibleOfferings, type ModelRow, type ModelProviderRow, type ModelOfferingRow, type Origin, type VisibleModel, type VisibleProvider, type ResolvedOffering, } from "./catalog-resolution.js";
 export { resolveModelSources, resolveInferencePreferences, resolveInstanceModelSources, resolveSourcesByOfferingIds, type CatalogSourceResolution, type OfferingSourceResolution, type SourceSkip, } from "./model-source-resolution.js";
-export { parseGrantRow, parseApprovalRow, parsePrincipalRow, parseSignalCorrelationRow, parseWorkflowRunRow, parseWorkflowRunDispatchRow, parseWorkflowRunLaunchSpecRow, parseWorkflowDefinitionRow, parseWorkflowDefinitionVersionRow, parseOfferingRow, parseModelOfferingRow, parseCredentialRow, parseProviderRow, parseTenantRow, parseWalletRow, parseTransactionRow, parseOAuthClientRow, parseGitTokenRow, parseTurnPartType, } from "./parse-row.js";
+export { parseGrantRow, parseApprovalRow, parsePrincipalRow, parsePrincipalKeyRow, parseSignalCorrelationRow, parseWorkflowRunRow, parseWorkflowRunDispatchRow, parseWorkflowRunLaunchSpecRow, parseWorkflowDefinitionRow, parseWorkflowDefinitionVersionRow, parseOfferingRow, parseModelOfferingRow, parseCredentialRow, parseProviderRow, parseTenantRow, parseWalletRow, parseTransactionRow, parseOAuthClientRow, parseGitTokenRow, parseTurnPartType, } from "./parse-row.js";
 export * as schema from "./schema/index.js";

package/dist/index.js

@@ -1,20 +1,26 @@
-export { createDB } from "./client.js";
+export { createDB, } from "./client.js";
 export { pgErrorCode, PG_UNIQUE_VIOLATION, PG_FOREIGN_KEY_VIOLATION, } from "./pg-error.js";
 export { runMigrations, dropSchema } from "./migrate.js";
 export { rekeyCredentialSecrets, } from "./rekey-credential-secrets.js";
+export { backfillPrincipalKeys, } from "./backfill-principal-keys.js";
 export { createGrantStore } from "./grant-store.js";
+export { createPrincipalStore } from "./principal-store.js";
+export { createPrincipalKeyStore, } from "./principal-key-store.js";
+export { lookupLocalPrincipalSigner } from "./signer-identity.js";
+export { resolveSenderKey, resolveFrameSenderKey, auditSenderKeys, } from "./sender-key-resolver.js";
 export { createApprovalStore, } from "./approval-store.js";
 export { createSignalCorrelationStore, } from "./signal-correlation-store.js";
 export { createWorkflowRunStore, } from "./workflow-run-store.js";
 export { createWorkflowRunLaunchSpecStore, } from "./workflow-run-launch-spec-store.js";
 export { createWorkflowRunDispatchStore, WorkflowRunDispatchPayloadConflictError, } from "./workflow-run-dispatch-store.js";
 export { createSidecarAllocationStore, } from "./sidecar-allocation-store.js";
+export { createWorkflowProbeStore, } from "./workflow-probe-store.js";
 export { createWorkflowDefinitionStore, loadFrozenGrantSnapshot, resolveDefinitionIdForAsset, } from "./workflow-definition-store.js";
-export { getAncestorChain, getDescendantTenants } from "./tenant-hierarchy.js";
+export { getAncestorChain, getDescendantTenants, resolveTenantSidecarCapabilityPolicies, } from "./tenant-hierarchy.js";
 export { resolveActivePrice } from "./pricing.js";
-export { resolveProviderByName, resolveOAuthClient, resolveCredentialByName, resolveCredentialById, resolveCredentialRequirement, resolveTenantOwnedCredentialById, AmbiguousCredentialError, buildCredentialDelivery, } from "./credential-resolution.js";
+export { resolveProviderByName, resolveOAuthClient, resolveCredentialByName, resolveCredentialById, resolveCredentialRequirement, resolveTenantOwnedCredentialById, resolveInferenceMaterials, reresolveCurrentMaterials, AmbiguousCredentialError, CredentialUnauthorizedError, buildCredentialDelivery, } from "./credential-resolution.js";
 export { resolveAssetByName, resolveAssetById, listAssetsForTenant, } from "./asset-resolution.js";
 export { listVisibleModels, listVisibleProviders, listVisibleOfferings, } from "./catalog-resolution.js";
 export { resolveModelSources, resolveInferencePreferences, resolveInstanceModelSources, resolveSourcesByOfferingIds, } from "./model-source-resolution.js";
-export { parseGrantRow, parseApprovalRow, parsePrincipalRow, parseSignalCorrelationRow, parseWorkflowRunRow, parseWorkflowRunDispatchRow, parseWorkflowRunLaunchSpecRow, parseWorkflowDefinitionRow, parseWorkflowDefinitionVersionRow, parseOfferingRow, parseModelOfferingRow, parseCredentialRow, parseProviderRow, parseTenantRow, parseWalletRow, parseTransactionRow, parseOAuthClientRow, parseGitTokenRow, parseTurnPartType, } from "./parse-row.js";
+export { parseGrantRow, parseApprovalRow, parsePrincipalRow, parsePrincipalKeyRow, parseSignalCorrelationRow, parseWorkflowRunRow, parseWorkflowRunDispatchRow, parseWorkflowRunLaunchSpecRow, parseWorkflowDefinitionRow, parseWorkflowDefinitionVersionRow, parseOfferingRow, parseModelOfferingRow, parseCredentialRow, parseProviderRow, parseTenantRow, parseWalletRow, parseTransactionRow, parseOAuthClientRow, parseGitTokenRow, parseTurnPartType, } from "./parse-row.js";
 export * as schema from "./schema/index.js";

package/dist/model-source-resolution.d.ts

@@ -1,5 +1,6 @@
 import { type CredentialCipher, type ModelRequirement, type ProviderPreference } from "@intx/types";
 import type { InferenceSource } from "@intx/types/runtime";
+import type { CredentialMaterialEntry } from "@intx/types/sidecar";
 import type { DB } from "./client.js";
 /**
  * Why a single offering could not be turned into a launchable source.
@@ -34,6 +35,7 @@ export type SourceSkip = {
 export type CatalogSourceResolution = {
     ok: true;
     sources: InferenceSource[];
+    materials: CredentialMaterialEntry[];
 } | {
     ok: false;
     reason: "no_requirements";
@@ -58,7 +60,7 @@ export type OfferingSourceResolution = {
  * secrets out of persisted launch specs and rechecks tenant visibility and
  * credential ownership on every launch.
  */
-export declare function resolveSourcesByOfferingIds(db: DB["db"], tenantId: string, offeringIds: readonly string[], credentialCipher?: CredentialCipher): Promise<OfferingSourceResolution>;
+export declare function resolveSourcesByOfferingIds(db: DB["db"], tenantId: string, offeringIds: readonly string[], credentialCipher: CredentialCipher): Promise<OfferingSourceResolution>;
 /**
  * Resolves an agent's model requirements against the tenant catalog into an
  * ordered `InferenceSource[]` for the harness.
@@ -76,9 +78,8 @@ export declare function resolveSourcesByOfferingIds(db: DB["db"], tenantId: stri
  * otherwise the offering is skipped (`credential_unauthorized`) and its secret
  * is withheld.
  */
-export declare function resolveModelSources(db: DB["db"], tenantId: string, requirements: ModelRequirement[], opts?: {
+export declare function resolveModelSources(db: DB["db"], tenantId: string, requirements: ModelRequirement[], credentialCipher: CredentialCipher, opts?: {
     invokerPreferences?: Record<string, ProviderPreference>;
-    credentialCipher?: CredentialCipher;
 }): Promise<CatalogSourceResolution>;
 /**
  * Resolve an agent's model requirements to the credential-free
@@ -97,7 +98,7 @@ export declare function resolveModelSources(db: DB["db"], tenantId: string, requ
  * an ambiguous preference list whose lost `offering.id` distinctions cannot be
  * recovered after the agent's columns are dropped.
  */
-export declare function resolveInferencePreferences(db: DB["db"], tenantId: string, requirements: ModelRequirement[]): Promise<{
+export declare function resolveInferencePreferences(db: DB["db"], tenantId: string, requirements: ModelRequirement[], credentialCipher: CredentialCipher): Promise<{
     provider: string;
     model: string;
 }[]>;
@@ -112,4 +113,4 @@ export declare function resolveInferencePreferences(db: DB["db"], tenantId: stri
 export declare function resolveInstanceModelSources(db: DB["db"], tenantId: string, instance: {
     definitionId: string;
     modelPreferences: unknown;
-}, credentialCipher?: CredentialCipher): Promise<CatalogSourceResolution>;
+}, credentialCipher: CredentialCipher): Promise<CatalogSourceResolution>;