@intx/db 0.3.0 → 0.4.0

package/dist/model-source-resolution.js

@@ -1,5 +1,4 @@
 import { and, eq } from "drizzle-orm";
-import { createNoopCredentialCipher } from "@intx/crypto";
 import { InvokerModelPreferences, ModelRequirements, credentialAad, } from "@intx/types";
 import { listVisibleOfferings, } from "./catalog-resolution.js";
 import { resolveCredentialById } from "./credential-resolution.js";
@@ -93,6 +92,13 @@ async function buildSource(db, tenantId, resolved, credentialCipher) {
     // filter in resolveModelSources still reads the raw row's `capabilities`
     // for its `.includes` check; that read-only comparison cannot be corrupted
     // into a wrong routing decision, so it is left as-is.
+    // Decrypt the stored secret at the one point it is used. Strict: a
+    // non-ciphertext value (a row not yet re-keyed, or a write that failed to
+    // encrypt) throws rather than delivering a bad key -- fail closed. The secret
+    // rides the credential-material cell (keyed by `credentialId`), NOT the source
+    // config -- the source only references the credential by id, so no secret is
+    // inline in the pinned/persisted source.
+    const secret = await credentialCipher.decrypt(credential.secret, credentialAad(credential.id, "secret"));
     const parsed = parseModelOfferingRow(offering);
     return {
         ok: true,
@@ -100,14 +106,17 @@ async function buildSource(db, tenantId, resolved, credentialCipher) {
             id: offering.id,
             provider: provider.plugin,
             baseURL: provider.baseURL,
-            // Decrypt the stored secret at the one point it is used. Strict: a
-            // non-ciphertext value (a row not yet re-keyed, or a write that failed to
-            // encrypt) throws rather than delivering a bad key -- fail closed.
-            apiKey: await credentialCipher.decrypt(credential.secret, credentialAad(credential.id, "secret")),
+            credentialId: provider.credentialId,
             model: model.canonicalName,
             capabilities: parsed.capabilities,
             ...(parsed.quirks !== null ? { quirks: parsed.quirks } : {}),
         },
+        material: {
+            credentialId: provider.credentialId,
+            providerKey: provider.plugin,
+            origin: provider.baseURL,
+            secret,
+        },
     };
 }
 /**
@@ -116,7 +125,7 @@ async function buildSource(db, tenantId, resolved, credentialCipher) {
  * secrets out of persisted launch specs and rechecks tenant visibility and
  * credential ownership on every launch.
  */
-export async function resolveSourcesByOfferingIds(db, tenantId, offeringIds, credentialCipher = createNoopCredentialCipher()) {
+export async function resolveSourcesByOfferingIds(db, tenantId, offeringIds, credentialCipher) {
     const visible = await listVisibleOfferings(db, tenantId);
     const byId = new Map(visible.map((entry) => [entry.offering.id, entry]));
     const sources = [];
@@ -155,13 +164,21 @@ export async function resolveSourcesByOfferingIds(db, tenantId, offeringIds, cre
  * otherwise the offering is skipped (`credential_unauthorized`) and its secret
  * is withheld.
  */
-export async function resolveModelSources(db, tenantId, requirements, opts) {
+export async function resolveModelSources(db, tenantId, requirements, 
+// Decrypts each resolved credential secret at its point of use in
+// `buildSource`. Required: the edge (the launch route / rotation push /
+// allocation service) owns the cipher and always supplies a real one; the
+// noop fallback for a keyless composition is resolved once at that edge
+// (`resolveCredentialCipher` in the hub app), never defaulted here.
+credentialCipher, opts) {
     if (requirements.length === 0) {
         return { ok: false, reason: "no_requirements" };
     }
-    const credentialCipher = opts?.credentialCipher ?? createNoopCredentialCipher();
     const visible = await listVisibleOfferings(db, tenantId);
     const sources = [];
+    // Dedupe material by credentialId across every requirement's chain: one
+    // credential backing several offerings is delivered once.
+    const materials = new Map();
     for (const requirement of requirements) {
         let candidates = visible
             .filter((o) => o.model.canonicalName === requirement.model)
@@ -174,10 +191,12 @@ export async function resolveModelSources(db, tenantId, requirements, opts) {
         candidates = applyPreference(candidates, opts?.invokerPreferences?.[requirement.model]);
         const skips = [];
         const modelSources = [];
+        const modelMaterials = [];
         for (const candidate of candidates) {
             const built = await buildSource(db, tenantId, candidate, credentialCipher);
             if (built.ok) {
                 modelSources.push(built.source);
+                modelMaterials.push(built.material);
             }
             else {
                 skips.push(built.skip);
@@ -192,8 +211,13 @@ export async function resolveModelSources(db, tenantId, requirements, opts) {
             };
         }
         sources.push(...modelSources);
+        for (const material of modelMaterials) {
+            if (!materials.has(material.credentialId)) {
+                materials.set(material.credentialId, material);
+            }
+        }
     }
-    return { ok: true, sources };
+    return { ok: true, sources, materials: [...materials.values()] };
 }
 /**
  * Resolve an agent's model requirements to the credential-free
@@ -212,8 +236,14 @@ export async function resolveModelSources(db, tenantId, requirements, opts) {
  * an ambiguous preference list whose lost `offering.id` distinctions cannot be
  * recovered after the agent's columns are dropped.
  */
-export async function resolveInferencePreferences(db, tenantId, requirements) {
-    const resolution = await resolveModelSources(db, tenantId, requirements);
+export async function resolveInferencePreferences(db, tenantId, requirements, 
+// Required even though the result discards the credential: this reuses the
+// full `resolveModelSources` path, which decrypts each secret at its point of
+// use in `buildSource` before the `{provider, model}` projection drops it. So
+// the caller must still supply the edge's real cipher; a noop here would throw
+// the moment a tenant's secret is stored encrypted.
+credentialCipher) {
+    const resolution = await resolveModelSources(db, tenantId, requirements, credentialCipher);
     if (!resolution.ok) {
         throw new Error(`cannot resolve inference preferences for the folded definition: ${resolution.reason}`);
     }
@@ -284,8 +314,7 @@ export async function resolveInstanceModelSources(db, tenantId, instance, creden
     for (const preference of preferences) {
         invokerPreferences[preference.model] = preference.providers;
     }
-    return resolveModelSources(db, tenantId, requirements, {
+    return resolveModelSources(db, tenantId, requirements, credentialCipher, {
         invokerPreferences,
-        ...(credentialCipher !== undefined ? { credentialCipher } : {}),
     });
 }

package/dist/parse-row.d.ts

@@ -1,4 +1,4 @@
-import type { approval, credential, gitToken, grant, modelOffering, modelProvider, oauthClient, offering, principal, provider, signalCorrelation, tenant, transaction, turnPart, wallet, workflowDefinition, workflowDefinitionVersion, workflowRun, workflowRunDispatch, workflowRunLaunchSpec } from "./schema/index.js";
+import type { approval, credential, gitToken, grant, modelOffering, modelProvider, oauthClient, offering, principal, principalKey, provider, signalCorrelation, tenant, transaction, turnPart, wallet, workflowDefinition, workflowDefinitionVersion, workflowRun, workflowRunDispatch, workflowRunLaunchSpec } from "./schema/index.js";
 export declare const GitTokenKindValidator: import("arktype/internal/variants/string.ts").StringType<"pat" | "svc", {}>;
 export declare function parseWorkflowDefinitionRow(row: typeof workflowDefinition.$inferSelect): {
     status: "deployed" | "stopped";
@@ -53,8 +53,8 @@ export declare function parseGrantRow(row: typeof grant.$inferSelect): {
     updatedAt: Date;
     expiresAt: Date | null;
     tenantId: string;
-    roleId: string | null;
     principalId: string | null;
+    roleId: string | null;
     resource: string;
     action: string;
 };
@@ -83,6 +83,15 @@ export declare function parsePrincipalRow(row: typeof principal.$inferSelect): {
     tenantId: string;
     refId: string;
 };
+export declare function parsePrincipalKeyRow(row: typeof principalKey.$inferSelect): {
+    status: "active" | "retired";
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    principalId: string;
+    publicKey: string;
+    privateKey: string;
+};
 export declare function parseSignalCorrelationRow(row: typeof signalCorrelation.$inferSelect): {
     kind: "approval";
     createdAt: Date;
@@ -107,13 +116,14 @@ export declare function parseWorkflowRunRow(row: typeof workflowRun.$inferSelect
     id: string;
     createdAt: Date;
     tenantId: string;
-    definitionId: string;
     principalId: string | null;
+    publicKey: string | null;
+    definitionId: string;
     anchorRunId: string | null;
     address: string | null;
-    publicKey: string | null;
     sidecarId: string | null;
     kernelId: string | null;
+    credentialRefs: import("./schema/index.js").WorkflowRunCredentialRefs | null;
     endedAt: Date | null;
 };
 export declare function parseWorkflowRunLaunchSpecRow(row: typeof workflowRunLaunchSpec.$inferSelect): {
@@ -148,6 +158,18 @@ export declare function parseWorkflowRunLaunchSpecRow(row: typeof workflowRunLau
                 locator: "tenant";
                 name?: string;
             }[];
+            sidecarPlacement?: {
+                capabilities?: {
+                    capability: string;
+                    effect: "require" | "block";
+                }[];
+            };
+            inboundMailPolicy?: {
+                untrustedFrom?: "reject" | "admit";
+                invalid?: "reject" | "admit";
+                missing?: "reject" | "admit";
+                unknown?: "reject" | "admit";
+            };
         };
         closure: {
             schemaVersion: "1";
@@ -186,7 +208,13 @@ export declare function parseWorkflowRunLaunchSpecRow(row: typeof workflowRunLau
             }[];
         };
         approvedWireHash: string;
-        approvedGrants: string[];
+        approvedGrants: (string | {
+            resource: string;
+            action: string;
+            source: "creator" | "invoker";
+            effect?: "allow" | "deny" | "ask";
+            conditions?: Record<string, unknown> | null;
+        })[];
     };
     sourceOfferingIds: string[];
     deployContent: Record<string, unknown>;
@@ -226,6 +254,7 @@ export declare function parseWorkflowRunDispatchRow(row: typeof workflowRunDispa
     nextAttemptAt: Date | null;
     failureCode: string | null;
     failureMessage: string | null;
+    senderAddress: string | null;
     rawMessage: Uint8Array<ArrayBufferLike>;
     acknowledgedGeneration: number | null;
     attemptCount: number;
@@ -256,8 +285,8 @@ export declare function parseCredentialRow(row: typeof credential.$inferSelect):
     expiresAt: Date | null;
     providerId: string;
     tenantId: string;
-    description: string | null;
     principalId: string | null;
+    description: string | null;
     scopes: string[] | null;
     oauthClientId: string | null;
     secret: string;
@@ -306,8 +335,10 @@ export declare function parseTenantRow(row: typeof tenant.$inferSelect): {
     config: {
         [x: string]: unknown;
         sidecarPlacement?: {
-            sharing: "exclusive";
-            reuse?: "never" | "same-deployment";
+            capabilities?: {
+                capability: string;
+                effect: "require" | "block";
+            }[];
         };
     } | null;
     domain: string;

package/dist/parse-row.js

@@ -33,6 +33,8 @@ const WorkflowDefinitionStatusValidator = type.enumerated(...workflowDefinitionS
 const WorkflowDefinitionVersionStatusValidator = type.enumerated(...workflowDefinitionVersionStatuses);
 const PrincipalKindValidator = type.enumerated(...principalKinds);
 const PrincipalStatusValidator = type.enumerated(...principalStatuses);
+const principalKeyStatuses = ["active", "retired"];
+const PrincipalKeyStatusValidator = type.enumerated(...principalKeyStatuses);
 const credentialTypes = [
     "api_key",
     "oauth_token",
@@ -113,6 +115,12 @@ export function parsePrincipalRow(row) {
         status: PrincipalStatusValidator.assert(row.status),
     };
 }
+export function parsePrincipalKeyRow(row) {
+    return {
+        ...row,
+        status: PrincipalKeyStatusValidator.assert(row.status),
+    };
+}
 export function parseSignalCorrelationRow(row) {
     return {
         ...row,

package/dist/principal-key-store.d.ts

@@ -0,0 +1,51 @@
+import type { CredentialCipher } from "@intx/types";
+import type { DB, DBExecutor } from "./client.js";
+type DBHandle = DB["db"];
+export type CreatePrincipalKeyStoreDeps = {
+    db: DBHandle;
+    /**
+     * Seals the private key seed at rest. Production supplies a real env-key
+     * cipher under `PRINCIPAL_KEY_ENCRYPTION_KEY`; tests and local dev may supply
+     * the noop cipher, which stores the seed as plaintext.
+     */
+    cipher: CredentialCipher;
+};
+/**
+ * Store for the `principal_key` table -- a principal's Ed25519 signing key.
+ *
+ * The hub custodies the private key: it mints, seals, and signs with it on the
+ * principal's behalf. A signature therefore ATTRIBUTES an action to a principal
+ * but is NOT non-repudiable against the hub operator, who holds the key. See
+ * docs/AUTH.md.
+ *
+ * The store owns the one-active-key-per-principal invariant end to end: `sign`
+ * and `getPublicKey` resolve the single active row, and `generate` inserts a new
+ * active key that the table's partial unique index rejects if the principal
+ * already has one. The private seed never leaves this module -- `sign` decrypts,
+ * signs, and discards it; no method returns private material.
+ */
+export declare function createPrincipalKeyStore({ db, cipher, }: CreatePrincipalKeyStoreDeps): {
+    /**
+     * Mint a fresh active signing key for a principal. Generates an Ed25519 key
+     * pair, seals the hex-encoded 32-byte seed with the cipher bound to the
+     * key's row and column, and inserts it. A principal that already holds an
+     * active key trips the partial unique index and this throws. Returns the
+     * hex-encoded public key; never returns private material.
+     */
+    generate(principalId: string, tx?: DBExecutor): Promise<string>;
+    /**
+     * Sign a message with the principal's active key. Decrypts the sealed seed,
+     * produces the raw 64-byte Ed25519 signature, and discards the seed. Throws
+     * when the principal has no active key. The seed stays a local that goes out
+     * of scope; it is never returned or logged.
+     */
+    sign(principalId: string, message: Uint8Array, tx?: DBExecutor): Promise<Uint8Array>;
+    /**
+     * The hex-encoded public key of a principal's active signing key. Throws
+     * when the principal has no active key rather than defaulting, so a missing
+     * key surfaces at the call site instead of downstream.
+     */
+    getPublicKey(principalId: string, tx?: DBExecutor): Promise<string>;
+};
+export type PrincipalKeyStore = ReturnType<typeof createPrincipalKeyStore>;
+export {};

package/dist/principal-key-store.js

@@ -0,0 +1,82 @@
+import { and, eq } from "drizzle-orm";
+import { generateKeyPair, signEd25519 } from "@intx/crypto";
+import { hexDecode, hexEncode, principalKeyAad } from "@intx/types";
+import { generateId } from "@intx/hub-common";
+import { principalKey } from "./schema/principal-keys.js";
+/**
+ * Store for the `principal_key` table -- a principal's Ed25519 signing key.
+ *
+ * The hub custodies the private key: it mints, seals, and signs with it on the
+ * principal's behalf. A signature therefore ATTRIBUTES an action to a principal
+ * but is NOT non-repudiable against the hub operator, who holds the key. See
+ * docs/AUTH.md.
+ *
+ * The store owns the one-active-key-per-principal invariant end to end: `sign`
+ * and `getPublicKey` resolve the single active row, and `generate` inserts a new
+ * active key that the table's partial unique index rejects if the principal
+ * already has one. The private seed never leaves this module -- `sign` decrypts,
+ * signs, and discards it; no method returns private material.
+ */
+export function createPrincipalKeyStore({ db, cipher, }) {
+    async function loadActive(principalId, tx) {
+        const [row] = await (tx ?? db)
+            .select()
+            .from(principalKey)
+            .where(and(eq(principalKey.principalId, principalId), eq(principalKey.status, "active")))
+            .limit(1);
+        return row;
+    }
+    return {
+        /**
+         * Mint a fresh active signing key for a principal. Generates an Ed25519 key
+         * pair, seals the hex-encoded 32-byte seed with the cipher bound to the
+         * key's row and column, and inserts it. A principal that already holds an
+         * active key trips the partial unique index and this throws. Returns the
+         * hex-encoded public key; never returns private material.
+         */
+        async generate(principalId, tx) {
+            const id = generateId("principalKey");
+            const keyPair = await generateKeyPair();
+            const sealedPrivateKey = await cipher.encrypt(hexEncode(keyPair.privateKey), principalKeyAad(id, "private_key"));
+            const publicKey = hexEncode(keyPair.publicKey);
+            const now = new Date();
+            await (tx ?? db).insert(principalKey).values({
+                id,
+                principalId,
+                publicKey,
+                privateKey: sealedPrivateKey,
+                status: "active",
+                createdAt: now,
+                updatedAt: now,
+            });
+            return publicKey;
+        },
+        /**
+         * Sign a message with the principal's active key. Decrypts the sealed seed,
+         * produces the raw 64-byte Ed25519 signature, and discards the seed. Throws
+         * when the principal has no active key. The seed stays a local that goes out
+         * of scope; it is never returned or logged.
+         */
+        async sign(principalId, message, tx) {
+            const row = await loadActive(principalId, tx);
+            if (row === undefined) {
+                throw new Error(`principalKeyStore.sign: principal ${principalId} has no active key`);
+            }
+            const seedHex = await cipher.decrypt(row.privateKey, principalKeyAad(row.id, "private_key"));
+            const seed = hexDecode(seedHex);
+            return signEd25519(seed, message);
+        },
+        /**
+         * The hex-encoded public key of a principal's active signing key. Throws
+         * when the principal has no active key rather than defaulting, so a missing
+         * key surfaces at the call site instead of downstream.
+         */
+        async getPublicKey(principalId, tx) {
+            const row = await loadActive(principalId, tx);
+            if (row === undefined) {
+                throw new Error(`principalKeyStore.getPublicKey: principal ${principalId} has no active key`);
+            }
+            return row.publicKey;
+        },
+    };
+}

package/dist/principal-store.d.ts

@@ -0,0 +1,44 @@
+import type { DB, DBExecutor } from "./client.js";
+import { principal } from "./schema/principals.js";
+import { parsePrincipalRow } from "./parse-row.js";
+import type { PrincipalKeyStore } from "./principal-key-store.js";
+type DBHandle = DB["db"];
+type PrincipalInsert = typeof principal.$inferInsert;
+type ParsedPrincipal = ReturnType<typeof parsePrincipalRow>;
+/**
+ * Store for the `principal` table -- the single owner of principal creation.
+ * Every principal insert in the system routes through this one factory, and
+ * every principal it creates is minted an active signing key in the same
+ * transaction, so a principal never exists without a key.
+ *
+ * Each method accepts an optional transaction handle so the principal row and
+ * its key join the transaction that co-writes the principal's roles and grants.
+ * When no handle is passed the store opens its own transaction, because the
+ * principal insert and the key mint are two writes that must commit together.
+ */
+export declare function createPrincipalStore(db: DBHandle, principalKeyStore: PrincipalKeyStore): {
+    /**
+     * Insert a new principal and mint its signing key, failing loudly on a
+     * natural-key conflict. Callers that have already established the principal
+     * is new (a fresh tenant owner, an invite past its existence pre-check) use
+     * this so a concurrent duplicate surfaces as a unique violation rather than
+     * a silent success.
+     */
+    create(row: PrincipalInsert, tx?: DBExecutor): Promise<ParsedPrincipal>;
+    /**
+     * Idempotent variant of `create` for the run path, where concurrent first
+     * deliveries race to reserve the same principal. On a win it inserts the
+     * principal, mints its key, and returns the parsed row; on a loss it returns
+     * `null` WITHOUT minting -- the winning transaction already minted the one
+     * active key -- so the caller can fall back to the winner's state.
+     *
+     * The conflict target is the natural key `(tenantId, kind, refId)`, NOT the
+     * surrogate `id`: user principals carry a random `generateId("principal")`,
+     * so their only real conflict key is the natural triple. The run path
+     * derives a deterministic id that agrees with the triple, so one target
+     * unifies both callers. Do not switch this to `principal.id`.
+     */
+    createIfAbsent(row: PrincipalInsert, tx?: DBExecutor): Promise<ParsedPrincipal | null>;
+};
+export type PrincipalStore = ReturnType<typeof createPrincipalStore>;
+export {};

package/dist/principal-store.js

@@ -0,0 +1,67 @@
+import { principal } from "./schema/principals.js";
+import { parsePrincipalRow } from "./parse-row.js";
+/**
+ * Store for the `principal` table -- the single owner of principal creation.
+ * Every principal insert in the system routes through this one factory, and
+ * every principal it creates is minted an active signing key in the same
+ * transaction, so a principal never exists without a key.
+ *
+ * Each method accepts an optional transaction handle so the principal row and
+ * its key join the transaction that co-writes the principal's roles and grants.
+ * When no handle is passed the store opens its own transaction, because the
+ * principal insert and the key mint are two writes that must commit together.
+ */
+export function createPrincipalStore(db, principalKeyStore) {
+    return {
+        /**
+         * Insert a new principal and mint its signing key, failing loudly on a
+         * natural-key conflict. Callers that have already established the principal
+         * is new (a fresh tenant owner, an invite past its existence pre-check) use
+         * this so a concurrent duplicate surfaces as a unique violation rather than
+         * a silent success.
+         */
+        async create(row, tx) {
+            const run = async (executor) => {
+                const [inserted] = await executor
+                    .insert(principal)
+                    .values(row)
+                    .returning();
+                if (inserted === undefined) {
+                    throw new Error(`principalStore.create: insert returned no row for ${row.id}`);
+                }
+                await principalKeyStore.generate(inserted.id, executor);
+                return parsePrincipalRow(inserted);
+            };
+            return tx === undefined ? db.transaction(run) : run(tx);
+        },
+        /**
+         * Idempotent variant of `create` for the run path, where concurrent first
+         * deliveries race to reserve the same principal. On a win it inserts the
+         * principal, mints its key, and returns the parsed row; on a loss it returns
+         * `null` WITHOUT minting -- the winning transaction already minted the one
+         * active key -- so the caller can fall back to the winner's state.
+         *
+         * The conflict target is the natural key `(tenantId, kind, refId)`, NOT the
+         * surrogate `id`: user principals carry a random `generateId("principal")`,
+         * so their only real conflict key is the natural triple. The run path
+         * derives a deterministic id that agrees with the triple, so one target
+         * unifies both callers. Do not switch this to `principal.id`.
+         */
+        async createIfAbsent(row, tx) {
+            const run = async (executor) => {
+                const [inserted] = await executor
+                    .insert(principal)
+                    .values(row)
+                    .onConflictDoNothing({
+                    target: [principal.tenantId, principal.kind, principal.refId],
+                })
+                    .returning();
+                if (inserted === undefined)
+                    return null;
+                await principalKeyStore.generate(inserted.id, executor);
+                return parsePrincipalRow(inserted);
+            };
+            return tx === undefined ? db.transaction(run) : run(tx);
+        },
+    };
+}

package/dist/schema/approvals.js

@@ -49,4 +49,9 @@ export const approval = pgTable("approval", {
 }, (t) => [
     index("approval_tenant_status_idx").on(t.tenantId, t.status, t.createdAt),
     index("approval_anchor_run_idx").on(t.anchorRunId),
+    // Reads that list a single run's approvals (the run-scoped approval and
+    // authorization views) filter on runId; the anchor_run index above does
+    // not serve them because a child run's approvals carry a runId distinct
+    // from the deployment's anchor.
+    index("approval_run_idx").on(t.runId),
 ]);

package/dist/schema/git-tokens.js

@@ -24,7 +24,7 @@ import { tenant } from "./tenants.js";
 // (`receivePack`, `createPack`, `resolveRef`, ...). The mint API
 // translates user-facing aliases to canonical names before insert.
 // `resource` is the single substrate authz resource string
-// (e.g. `agent-state:run_xxx`, `asset:def_yyy`) that the token grants
+// (e.g. `agent-state:run_xxx`, `asset:ast_yyy`) that the token grants
 // access to. `refPattern` is a glob restricting which refs within the
 // resource the token may read or write.
 //

package/dist/schema/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./auth.js";
 export * from "./tenants.js";
 export * from "./principals.js";
+export * from "./principal-keys.js";
 export * from "./roles.js";
 export * from "./grants.js";
 export * from "./approvals.js";
@@ -23,3 +24,4 @@ export * from "./workflow-run.js";
 export * from "./workflow-run-dispatch.js";
 export * from "./workflow-run-launch-spec.js";
 export * from "./workflow-run-execution.js";
+export * from "./workflow-probe.js";

package/dist/schema/index.js

@@ -1,6 +1,7 @@
 export * from "./auth.js";
 export * from "./tenants.js";
 export * from "./principals.js";
+export * from "./principal-keys.js";
 export * from "./roles.js";
 export * from "./grants.js";
 export * from "./approvals.js";
@@ -23,3 +24,4 @@ export * from "./workflow-run.js";
 export * from "./workflow-run-dispatch.js";
 export * from "./workflow-run-launch-spec.js";
 export * from "./workflow-run-execution.js";
+export * from "./workflow-probe.js";