@openlup/platform 0.0.0 → 0.16.0

package/dist/identity/removeAdminUserUseCase.js

@@ -0,0 +1,60 @@
+import { identityMessages } from "./messages.js";
+export async function runRemoveAdminUserUseCase(request, gateway, messages = identityMessages.en, invitationStore) {
+    try {
+        if (!request.accessToken) {
+            return { status: 401, body: { code: "UNAUTHORIZED", error: messages.unauthorized } };
+        }
+        const { user, error: authError } = await gateway.getUser(request.accessToken);
+        if (authError || !user) {
+            return { status: 401, body: { code: "INVALID_TOKEN", error: messages.invalidToken } };
+        }
+        const callerAdmin = await gateway.findAdminUser(user.id);
+        if (!callerAdmin || callerAdmin.role !== "admin") {
+            return { status: 403, body: { code: "REMOVE_FORBIDDEN", error: messages.removeForbidden } };
+        }
+        if (!request.userId) {
+            return { status: 400, body: { code: "USER_ID_REQUIRED", error: messages.userIdRequired } };
+        }
+        if (request.userId === user.id) {
+            return { status: 403, body: { code: "SELF_REVOKE_FORBIDDEN", error: messages.selfRemoveForbidden } };
+        }
+        if (invitationStore) {
+            try {
+                await invitationStore.remove({ actorPrincipalId: user.id, targetPrincipalId: request.userId });
+                return { status: 200, body: { revoked: true } };
+            }
+            catch (error) {
+                const failure = error;
+                if (failure.identityCode)
+                    return { status: failure.bffCode === "FORBIDDEN" ? 403 : failure.bffCode === "BAD_REQUEST" ? 400 : 409, body: { code: failure.identityCode, error: failure.identityCode } };
+                return mapRevokeError(failure.message ?? "revoke_failed", messages);
+            }
+        }
+        const { error: revokeError } = await gateway.revokeAdminUser(request.userId);
+        if (revokeError) {
+            return mapRevokeError(revokeError.message, messages);
+        }
+        return { status: 200, body: { revoked: true } };
+    }
+    catch (err) {
+        return { status: 500, body: { code: "IDENTITY_ACTION_FAILED", error: String(err) } };
+    }
+}
+function mapRevokeError(message, messages) {
+    if (message.includes("last_active_human_admin") || message.includes("last_admin_lockout")) {
+        return { status: 409, body: { code: "LAST_ACTIVE_HUMAN_ADMIN", error: messages.lastAdmin } };
+    }
+    if (message.includes("self_revoke_forbidden")) {
+        return { status: 403, body: { code: "SELF_REVOKE_FORBIDDEN", error: messages.selfRevoke } };
+    }
+    if (message.includes("machine_actor_revoke_forbidden")) {
+        return { status: 403, body: { code: "MACHINE_ACTOR_REVOKE_FORBIDDEN", error: messages.machineRevoke } };
+    }
+    if (message.includes("target_not_found") || message.includes("target_not_active")) {
+        return { status: 400, body: { code: "ADMIN_NOT_FOUND", error: messages.adminNotFound } };
+    }
+    if (message.includes("forbidden")) {
+        return { status: 403, body: { code: "ADMIN_REQUIRED", error: messages.adminRequired } };
+    }
+    return { status: 500, body: { code: "REVOKE_FAILED", error: messages.revokeFailed(message) } };
+}

package/dist/identity/response.d.ts

@@ -0,0 +1,3 @@
+import { createBffResponder, type BffResponderOptions } from "../bff/index.js";
+export type IdentityResponseOptions = BffResponderOptions;
+export declare const createIdentityResponder: typeof createBffResponder;

package/dist/identity/response.js

@@ -0,0 +1,2 @@
+import { createBffResponder } from "../bff/index.js";
+export const createIdentityResponder = createBffResponder;

package/dist/identity/sql.d.ts

@@ -0,0 +1,44 @@
+/** A projection of canonical migration units, never a second migration chain. */
+export declare const IDENTITY_MIGRATIONS: readonly [{
+    readonly id: "20260810180001_self_host_actor_auth";
+    readonly catalogPath: "db/platform/migrations/20260810180001_self_host_actor_auth.sql";
+    readonly position: 11;
+    readonly sha256: "84c80d328785151f1fdb5fc4b69220469ffb9c8579054c473ead910a273dfe7b";
+    readonly url: URL;
+}, {
+    readonly id: "20260810204057_customer_identity_read";
+    readonly catalogPath: "db/platform/migrations/20260810204057_customer_identity_read.sql";
+    readonly position: 12;
+    readonly sha256: "1aa626c0187a4ed9d08f152540e0d17c68cd678d2caf3e896ac444b5a38aafe3";
+    readonly url: URL;
+}, {
+    readonly id: "20260814090000_customer_selfservice_recovery";
+    readonly catalogPath: "db/platform/migrations/20260814090000_customer_selfservice_recovery.sql";
+    readonly position: 29;
+    readonly sha256: "ca7f58994533727eb58da148d549ff986fe8f55bb2ffc9eaf61e7d239675ba2e";
+    readonly url: URL;
+}, {
+    readonly id: "20260901143000_admin_membership_authority_foundation";
+    readonly catalogPath: "db/platform/migrations/20260901143000_admin_membership_authority_foundation.sql";
+    readonly position: 60;
+    readonly sha256: "bb4703b669d17e5a0eb4d9a4e8889d12e5286d4b5a813226a77ef2b71df8281f";
+    readonly url: URL;
+}, {
+    readonly id: "20261018120000_identity_operator_invitations";
+    readonly catalogPath: "db/platform/migrations/20261018120000_identity_operator_invitations.sql";
+    readonly position: 67;
+    readonly sha256: "b73034908bd5e27819bcd421d17037a0f00a24aa3df1be1f8f9ca411bf984349";
+    readonly url: URL;
+}, {
+    readonly id: "20261018180000_identity_operator_challenges";
+    readonly catalogPath: "db/platform/migrations/20261018180000_identity_operator_challenges.sql";
+    readonly position: 68;
+    readonly sha256: "191cf0c151a5882ad20d6043624da50afad799df739fff326d67560d3e00a031";
+    readonly url: URL;
+}, {
+    readonly id: "20261018190000_identity_privacy_erasures";
+    readonly catalogPath: "db/platform/migrations/20261018190000_identity_privacy_erasures.sql";
+    readonly position: 69;
+    readonly sha256: "f39b691cb14c0e9ec1a7460d77dc46e16bca4d2448838e4882f78885a6d92351";
+    readonly url: URL;
+}];

package/dist/identity/sql.js

@@ -0,0 +1,10 @@
+/** A projection of canonical migration units, never a second migration chain. */
+export const IDENTITY_MIGRATIONS = [
+    { id: "20260810180001_self_host_actor_auth", catalogPath: "db/platform/migrations/20260810180001_self_host_actor_auth.sql", position: 11, sha256: "84c80d328785151f1fdb5fc4b69220469ffb9c8579054c473ead910a273dfe7b", url: new URL("../../sql/20260810180001_self_host_actor_auth.sql", import.meta.url) },
+    { id: "20260810204057_customer_identity_read", catalogPath: "db/platform/migrations/20260810204057_customer_identity_read.sql", position: 12, sha256: "1aa626c0187a4ed9d08f152540e0d17c68cd678d2caf3e896ac444b5a38aafe3", url: new URL("../../sql/20260810204057_customer_identity_read.sql", import.meta.url) },
+    { id: "20260814090000_customer_selfservice_recovery", catalogPath: "db/platform/migrations/20260814090000_customer_selfservice_recovery.sql", position: 29, sha256: "ca7f58994533727eb58da148d549ff986fe8f55bb2ffc9eaf61e7d239675ba2e", url: new URL("../../sql/20260814090000_customer_selfservice_recovery.sql", import.meta.url) },
+    { id: "20260901143000_admin_membership_authority_foundation", catalogPath: "db/platform/migrations/20260901143000_admin_membership_authority_foundation.sql", position: 60, sha256: "bb4703b669d17e5a0eb4d9a4e8889d12e5286d4b5a813226a77ef2b71df8281f", url: new URL("../../sql/20260901143000_admin_membership_authority_foundation.sql", import.meta.url) },
+    { id: "20261018120000_identity_operator_invitations", catalogPath: "db/platform/migrations/20261018120000_identity_operator_invitations.sql", position: 67, sha256: "b73034908bd5e27819bcd421d17037a0f00a24aa3df1be1f8f9ca411bf984349", url: new URL("../../sql/20261018120000_identity_operator_invitations.sql", import.meta.url) },
+    { id: "20261018180000_identity_operator_challenges", catalogPath: "db/platform/migrations/20261018180000_identity_operator_challenges.sql", position: 68, sha256: "191cf0c151a5882ad20d6043624da50afad799df739fff326d67560d3e00a031", url: new URL("../../sql/20261018180000_identity_operator_challenges.sql", import.meta.url) },
+    { id: "20261018190000_identity_privacy_erasures", catalogPath: "db/platform/migrations/20261018190000_identity_privacy_erasures.sql", position: 69, sha256: "f39b691cb14c0e9ec1a7460d77dc46e16bca4d2448838e4882f78885a6d92351", url: new URL("../../sql/20261018190000_identity_privacy_erasures.sql", import.meta.url) },
+];

package/dist/job-ledger/index.d.ts

@@ -0,0 +1,5 @@
+export type { PlatformJobBackstopState, PlatformJobClaim, PlatformJobFinishStatus, PlatformJobFinishSummary, PlatformJobInvocation, PlatformJobRunLedgerPort, PlatformJobTriggerKind, } from "./ports.js";
+export type { PgQueryExecutor } from "../data/index.js";
+export { createPostgresPlatformJobRunLedger, type PostgresPlatformJobRunLedgerOptions, } from "./postgres.js";
+export { JOB_RUN_LEDGER_MIGRATIONS, JOB_RUN_LEDGER_SQL_URL, JOB_RUN_LEDGER_V3_SQL_URL } from "./sql.js";
+export { createManagedJobRunCalls, createSupabasePlatformJobRunLedger, platformJobInvocationForDriver, type ManagedJobRunOptions, type PlatformJobClient, type PlatformJobDriver, type PlatformJobSupabaseClient, type SupabasePlatformJobRunLedgerOptions, } from "./supabase.js";

package/dist/job-ledger/index.js

@@ -0,0 +1,3 @@
+export { createPostgresPlatformJobRunLedger, } from "./postgres.js";
+export { JOB_RUN_LEDGER_MIGRATIONS, JOB_RUN_LEDGER_SQL_URL, JOB_RUN_LEDGER_V3_SQL_URL } from "./sql.js";
+export { createManagedJobRunCalls, createSupabasePlatformJobRunLedger, platformJobInvocationForDriver, } from "./supabase.js";

package/dist/job-ledger/ports.d.ts

@@ -0,0 +1,10 @@
+import type { JobLeasePort } from "@openlup/core/platform-runtime";
+export type { PlatformJobClaim, PlatformJobFinishStatus, PlatformJobFinishSummary, PlatformJobInvocation, PlatformJobTriggerKind, } from "@openlup/core/platform-runtime";
+export type PlatformJobBackstopState = {
+    lastStatus: string | null;
+    lastSuccessAt: string | null;
+};
+export interface PlatformJobRunLedgerPort extends JobLeasePort {
+    readJobBackstopState(jobName: string): Promise<PlatformJobBackstopState | null>;
+    readLatestTerminalRunMetadata(jobName: string): Promise<Record<string, unknown> | null>;
+}

package/dist/job-ledger/ports.js

@@ -0,0 +1,7 @@
+// Persistence-neutral scheduled-job lease and attempt ledger port.
+//
+// The claim and finish contract is core's `JobLeasePort`. A job-run ledger adds the two reads a
+// scheduled job uses for its backstop and checkpoint. Invocation is deployment evidence supplied by
+// the composition root; a job never sees a database client, SDK query, RPC name, vendor driver or
+// environment configuration.
+export {};

package/dist/job-ledger/postgres.d.ts

@@ -0,0 +1,10 @@
+import type { PgQueryExecutor } from "../data/index.js";
+import type { PlatformJobRunLedgerPort } from "./ports.js";
+export interface PostgresPlatformJobRunLedgerOptions {
+    /** Release and deployment identity merged into every claim and finish row's metadata. */
+    releaseCorrelation: () => Record<string, string | null>;
+    /** Failure reason recorded when a failed run's summary carries none. */
+    defaultFailureReason: string;
+}
+/** Direct PostgreSQL adapter for the public neutral-vocabulary job-control rail. */
+export declare function createPostgresPlatformJobRunLedger(executor: PgQueryExecutor, options: PostgresPlatformJobRunLedgerOptions): PlatformJobRunLedgerPort;

package/dist/job-ledger/postgres.js

@@ -0,0 +1,101 @@
+// Direct PostgreSQL adapter for the public job-run ledger (claim, finish, backstop, checkpoint).
+//
+// The RPCs and tables come from the package's job-run ledger SQL. Every claim and finish row
+// carries the invocation and the deployment's release correlation in its metadata.
+const CLAIM_SQL = `
+  SELECT acquired, run_id, reason
+  FROM public.platform_claim_job_run_v3($1, $2, $3, $4, $5::jsonb)`;
+const FINISH_SQL = `
+  SELECT public.platform_finish_job_run_v3(
+    $1, $2::uuid, $3, $4, $5, $6, $7, $8::jsonb
+  ) AS released`;
+const BACKSTOP_SQL = `
+  SELECT last_status, last_success_at
+  FROM public.platform_job_controls
+  WHERE job_name = $1`;
+const LATEST_TERMINAL_METADATA_SQL = `
+  SELECT metadata
+  FROM public.platform_job_runs
+  WHERE job_name = $1
+    AND status IN ('success', 'failed')
+    AND finished_at IS NOT NULL
+  ORDER BY started_at DESC
+  LIMIT 1`;
+/** Direct PostgreSQL adapter for the public neutral-vocabulary job-control rail. */
+export function createPostgresPlatformJobRunLedger(executor, options) {
+    return {
+        async claimJobRun(jobName, invocation, leaseSeconds = 900) {
+            const invocationSource = requiredInvocationSource(invocation.invocationSource);
+            const result = await executor.query(CLAIM_SQL, [
+                jobName,
+                invocation.triggerKind,
+                invocationSource,
+                leaseSeconds,
+                {
+                    triggerKind: invocation.triggerKind,
+                    invocationSource,
+                    ...options.releaseCorrelation(),
+                },
+            ]);
+            const row = plainRecord(result.rows[0]);
+            return {
+                acquired: row?.acquired === true,
+                runId: typeof row?.run_id === "string" ? row.run_id : null,
+                reason: typeof row?.reason === "string" ? row.reason : "unknown",
+            };
+        },
+        async finishJobRun(jobName, runId, invocation, status, summary, extraMetadata) {
+            const invocationSource = requiredInvocationSource(invocation.invocationSource);
+            const result = await executor.query(FINISH_SQL, [
+                jobName,
+                runId,
+                status,
+                summary.checked,
+                summary.updated,
+                status === "failed" ? summary.reason ?? options.defaultFailureReason : null,
+                null,
+                {
+                    failures: summary.failures,
+                    skipped: summary.skipped,
+                    reason: summary.reason ?? null,
+                    ...options.releaseCorrelation(),
+                    ...(extraMetadata ?? {}),
+                    triggerKind: invocation.triggerKind,
+                    invocationSource,
+                    driver: invocationSource,
+                },
+            ]);
+            return plainRecord(result.rows[0])?.released === true;
+        },
+        async readJobBackstopState(jobName) {
+            const result = await executor.query(BACKSTOP_SQL, [jobName]);
+            const row = plainRecord(result.rows[0]);
+            return row ? {
+                lastStatus: typeof row.last_status === "string" ? row.last_status : null,
+                lastSuccessAt: timestampString(row.last_success_at),
+            } : null;
+        },
+        async readLatestTerminalRunMetadata(jobName) {
+            const result = await executor.query(LATEST_TERMINAL_METADATA_SQL, [jobName]);
+            return plainRecord(plainRecord(result.rows[0])?.metadata);
+        },
+    };
+}
+function plainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    return { ...value };
+}
+function timestampString(value) {
+    if (typeof value === "string")
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    return null;
+}
+function requiredInvocationSource(value) {
+    const source = value.trim();
+    if (!source)
+        throw new Error("platform_job_invocation_source_required");
+    return source;
+}

package/dist/job-ledger/sql.d.ts

@@ -0,0 +1,7 @@
+export declare const JOB_RUN_LEDGER_SQL_URL: URL;
+export declare const JOB_RUN_LEDGER_V3_SQL_URL: URL;
+/** Every job-run ledger migration, ordered by migration identity. */
+export declare const JOB_RUN_LEDGER_MIGRATIONS: ReadonlyArray<{
+    readonly id: string;
+    readonly url: URL;
+}>;

package/dist/job-ledger/sql.js

@@ -0,0 +1,10 @@
+// The job-run ledger SQL a fresh installation applies through its own migration chain, in order.
+// The first file's bytes and migration identity equal the reference application's platform
+// migration of the same name; the second adds the v3 claim and finish entry points.
+export const JOB_RUN_LEDGER_SQL_URL = new URL("../../sql/20260809150000_job_run_ledger.sql", import.meta.url);
+export const JOB_RUN_LEDGER_V3_SQL_URL = new URL("../../sql/20260809150001_job_run_ledger_v3.sql", import.meta.url);
+/** Every job-run ledger migration, ordered by migration identity. */
+export const JOB_RUN_LEDGER_MIGRATIONS = [
+    { id: "20260809150000_job_run_ledger", url: JOB_RUN_LEDGER_SQL_URL },
+    { id: "20260809150001_job_run_ledger_v3", url: JOB_RUN_LEDGER_V3_SQL_URL },
+];

package/dist/job-ledger/supabase.d.ts

@@ -0,0 +1,77 @@
+import type { PlatformJobFinishStatus, PlatformJobFinishSummary, PlatformJobInvocation, PlatformJobRunLedgerPort } from "./ports.js";
+export type PlatformJobDriver = "manual_admin" | "pg_cron" | "vercel_cron" | "worker";
+type RpcResult<T> = {
+    data: T | null;
+    error: {
+        message?: string;
+    } | null;
+};
+type PlatformJobMetadataQuery = {
+    select(columns: "metadata"): PlatformJobMetadataQuery;
+    eq(column: "job_name", value: string): PlatformJobMetadataQuery;
+    in(column: "status", values: readonly ["success", "failed"]): PlatformJobMetadataQuery;
+    not(column: "finished_at", operator: "is", value: null): PlatformJobMetadataQuery;
+    order(column: "started_at", options: {
+        ascending: false;
+    }): PlatformJobMetadataQuery;
+    limit(count: 1): PlatformJobMetadataQuery;
+    maybeSingle(): PromiseLike<{
+        data: {
+            metadata?: unknown;
+        } | null;
+        error: {
+            message?: string;
+        } | null;
+    }>;
+};
+type PlatformJobControlQuery = {
+    select(columns: "last_status,last_success_at"): PlatformJobControlQuery;
+    eq(column: "job_name", value: string): PlatformJobControlQuery;
+    maybeSingle(): PromiseLike<{
+        data: {
+            last_status?: string | null;
+            last_success_at?: string | null;
+        } | null;
+        error: {
+            message?: string;
+        } | null;
+    }>;
+};
+export interface PlatformJobSupabaseClient {
+    rpc<T = unknown>(name: string, args: Record<string, unknown>): PromiseLike<RpcResult<T>>;
+    from(table: "platform_job_runs"): PlatformJobMetadataQuery;
+    from(table: "platform_job_controls"): PlatformJobControlQuery;
+}
+/** Minimal compatibility client for the legacy free-function surface. */
+export type PlatformJobClient = Pick<PlatformJobSupabaseClient, "rpc">;
+export declare function platformJobInvocationForDriver(driver: PlatformJobDriver): PlatformJobInvocation;
+export interface ManagedJobRunOptions {
+    /** Release and deployment identity merged into every claim and finish row's metadata. */
+    releaseCorrelation: () => Record<string, string | null>;
+    /** Failure reason recorded when a failed run's summary carries none. */
+    defaultFailureReason: string;
+}
+export interface SupabasePlatformJobRunLedgerOptions extends ManagedJobRunOptions {
+    /** Message of the error thrown when the backstop state cannot be read. */
+    backstopReadError: string;
+    /** Message of the error thrown when the latest terminal run cannot be read. */
+    checkpointReadError: string;
+}
+/** The managed v2/v3 compatibility calls, bound to the deployment's release correlation. */
+export declare function createManagedJobRunCalls(options: ManagedJobRunOptions): {
+    claimJobRun: (client: PlatformJobClient, jobName: string, driver: PlatformJobDriver, leaseSeconds?: number) => Promise<{
+        acquired: boolean;
+        runId: string | null;
+        reason: string;
+    }>;
+    claimJobRunV3: (client: PlatformJobClient, jobName: string, invocation: PlatformJobInvocation, leaseSeconds?: number) => Promise<{
+        acquired: boolean;
+        runId: string | null;
+        reason: string;
+    }>;
+    finishJobRun: (client: PlatformJobClient, jobName: string, runId: string, status: PlatformJobFinishStatus, result: PlatformJobFinishSummary, extraMetadata?: Record<string, unknown>) => Promise<boolean>;
+    finishJobRunV3: (client: PlatformJobClient, jobName: string, runId: string, status: PlatformJobFinishStatus, result: PlatformJobFinishSummary, extraMetadata?: Record<string, unknown>) => Promise<void>;
+};
+/** Managed adapter for the semantic job-run port. */
+export declare function createSupabasePlatformJobRunLedger(client: PlatformJobSupabaseClient, options: SupabasePlatformJobRunLedgerOptions): PlatformJobRunLedgerPort;
+export {};

package/dist/job-ledger/supabase.js

@@ -0,0 +1,202 @@
+// Managed (Supabase) adapter for the job-run ledger, and the managed v2/v3 compatibility calls.
+//
+// It speaks the managed job-control RPCs (`platform_claim_job_run`, `platform_finish_job_run_v2`
+// and their v3 forms) through an injected client. Every claim and finish row carries the
+// deployment's release correlation; the default failure reason and the two read-failure messages
+// are the deployment's own values.
+function triggerSourceForDriver(driver) {
+    switch (driver) {
+        case "vercel_cron": return "vercel_cron";
+        case "pg_cron": return "pg_cron_scheduler";
+        case "worker": return "worker";
+        case "manual_admin": return "manual_admin";
+    }
+}
+export function platformJobInvocationForDriver(driver) {
+    switch (driver) {
+        case "manual_admin": return { triggerKind: "operator", invocationSource: driver };
+        case "pg_cron":
+        case "vercel_cron": return { triggerKind: "scheduler", invocationSource: driver };
+        case "worker": return { triggerKind: "worker", invocationSource: driver };
+    }
+}
+function managedDriverForInvocation(invocation) {
+    if (!["worker", "scheduler", "operator"].includes(invocation.triggerKind)) {
+        throw new Error("platform_job_invalid_trigger_kind");
+    }
+    const source = invocation.invocationSource.trim();
+    const driver = source;
+    const expected = platformJobInvocationForDriver(driver);
+    if (!expected || expected.triggerKind !== invocation.triggerKind) {
+        throw new Error("platform_job_invalid_invocation");
+    }
+    return driver;
+}
+function claimResult(data) {
+    const row = Array.isArray(data) ? data[0] : data;
+    const record = plainRecord(row);
+    return {
+        acquired: record?.acquired === true,
+        runId: typeof record?.run_id === "string" ? record.run_id : null,
+        reason: typeof record?.reason === "string" ? record.reason : "unknown",
+    };
+}
+/** The managed v2/v3 compatibility calls, bound to the deployment's release correlation. */
+export function createManagedJobRunCalls(options) {
+    /** Compatibility surface for existing managed v2 consumers. */
+    async function claimJobRun(client, jobName, driver, leaseSeconds = 900) {
+        const { data, error } = await client.rpc("platform_claim_job_run", {
+            p_job_name: jobName,
+            p_driver: driver,
+            p_lease_seconds: leaseSeconds,
+            p_metadata: {
+                driver,
+                triggerSource: driver === "vercel_cron" ? "vercel_cron_manual" : driver,
+                ...options.releaseCorrelation(),
+            },
+        });
+        if (error)
+            throw new Error(error.message ?? "platform_claim_job_run failed");
+        return claimResult(data);
+    }
+    /** Compatibility surface for existing managed v3 consumers. */
+    async function claimJobRunV3(client, jobName, invocation, leaseSeconds = 900) {
+        const invocationSource = invocation.invocationSource.trim();
+        if (!invocationSource)
+            throw new Error("platform_job_invocation_source_required");
+        const { data, error } = await client.rpc("platform_claim_job_run_v3", {
+            p_job_name: jobName,
+            p_trigger_kind: invocation.triggerKind,
+            p_invocation_source: invocationSource,
+            p_lease_seconds: leaseSeconds,
+            p_metadata: {
+                triggerKind: invocation.triggerKind,
+                invocationSource,
+                ...options.releaseCorrelation(),
+            },
+        });
+        if (error)
+            throw new Error(error.message ?? "platform_claim_job_run_v3 failed");
+        return claimResult(data);
+    }
+    /** Compatibility surface for existing managed v2 consumers. */
+    async function finishJobRun(client, jobName, runId, status, result, extraMetadata) {
+        const { data, error } = await client.rpc("platform_finish_job_run_v2", {
+            p_job_name: jobName,
+            p_run_id: runId,
+            p_status: status,
+            p_checked: result.checked,
+            p_updated: result.updated,
+            p_error: status === "failed" ? result.reason ?? options.defaultFailureReason : null,
+            p_support_code: null,
+            p_metadata: {
+                driver: "manual_admin",
+                failures: result.failures,
+                skipped: result.skipped,
+                reason: result.reason ?? null,
+                ...options.releaseCorrelation(),
+                ...(extraMetadata ?? {}),
+            },
+        });
+        if (error)
+            throw new Error(error.message ?? "platform_finish_job_run_v2 failed");
+        return data === true;
+    }
+    /** Compatibility surface for existing managed v3 consumers. */
+    async function finishJobRunV3(client, jobName, runId, status, result, extraMetadata) {
+        const { error } = await client.rpc("platform_finish_job_run_v3", {
+            p_job_name: jobName,
+            p_run_id: runId,
+            p_status: status,
+            p_checked: result.checked,
+            p_updated: result.updated,
+            p_error: status === "failed" ? result.reason ?? options.defaultFailureReason : null,
+            p_support_code: null,
+            p_metadata: {
+                failures: result.failures,
+                skipped: result.skipped,
+                reason: result.reason ?? null,
+                ...options.releaseCorrelation(),
+                ...(extraMetadata ?? {}),
+            },
+        });
+        if (error)
+            throw new Error(error.message ?? "platform_finish_job_run_v3 failed");
+    }
+    return { claimJobRun, claimJobRunV3, finishJobRun, finishJobRunV3 };
+}
+/** Managed adapter for the semantic job-run port. */
+export function createSupabasePlatformJobRunLedger(client, options) {
+    return {
+        async claimJobRun(jobName, invocation, leaseSeconds = 900) {
+            const driver = managedDriverForInvocation(invocation);
+            const { data, error } = await client.rpc("platform_claim_job_run", {
+                p_job_name: jobName,
+                p_driver: driver,
+                p_lease_seconds: leaseSeconds,
+                p_metadata: {
+                    driver,
+                    triggerSource: triggerSourceForDriver(driver),
+                    ...options.releaseCorrelation(),
+                },
+            });
+            if (error)
+                throw new Error(error.message ?? "platform_claim_job_run failed");
+            return claimResult(data);
+        },
+        async finishJobRun(jobName, runId, invocation, status, result, extraMetadata) {
+            const driver = managedDriverForInvocation(invocation);
+            const { data, error } = await client.rpc("platform_finish_job_run_v2", {
+                p_job_name: jobName,
+                p_run_id: runId,
+                p_status: status,
+                p_checked: result.checked,
+                p_updated: result.updated,
+                p_error: status === "failed" ? result.reason ?? options.defaultFailureReason : null,
+                p_support_code: null,
+                p_metadata: {
+                    failures: result.failures,
+                    skipped: result.skipped,
+                    reason: result.reason ?? null,
+                    ...options.releaseCorrelation(),
+                    ...(extraMetadata ?? {}),
+                    driver,
+                },
+            });
+            if (error)
+                throw new Error(error.message ?? "platform_finish_job_run_v2 failed");
+            return data === true;
+        },
+        async readJobBackstopState(jobName) {
+            const { data, error } = await client
+                .from("platform_job_controls")
+                .select("last_status,last_success_at")
+                .eq("job_name", jobName)
+                .maybeSingle();
+            if (error)
+                throw new Error(options.backstopReadError);
+            return data ? {
+                lastStatus: data.last_status ?? null,
+                lastSuccessAt: data.last_success_at ?? null,
+            } : null;
+        },
+        async readLatestTerminalRunMetadata(jobName) {
+            const { data, error } = await client
+                .from("platform_job_runs")
+                .select("metadata")
+                .eq("job_name", jobName)
+                .in("status", ["success", "failed"])
+                .order("started_at", { ascending: false })
+                .limit(1)
+                .maybeSingle();
+            if (error)
+                throw new Error(options.checkpointReadError);
+            return plainRecord(data?.metadata);
+        },
+    };
+}
+function plainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    return { ...value };
+}

package/dist/kernel/index.d.ts

@@ -0,0 +1 @@
+export { BLOB_CAPABILITIES, DEFAULT_PLATFORM_BUNDLE, ENV_MISSING_CODE, PLATFORM_BUNDLE_DESCRIPTORS, PLATFORM_BUNDLE_IDS, getBundleDescriptor, isPlatformBundleId, platformEnvSchema, resolveBlobCapability, resolveBundleId, type BlobCapability, type PlatformBundleDescriptor, type PlatformBundleId, type PlatformBundleReadiness, type PlatformEnv, } from "./platformKernel.js";

package/dist/kernel/index.js

@@ -0,0 +1 @@
+export { BLOB_CAPABILITIES, DEFAULT_PLATFORM_BUNDLE, ENV_MISSING_CODE, PLATFORM_BUNDLE_DESCRIPTORS, PLATFORM_BUNDLE_IDS, getBundleDescriptor, isPlatformBundleId, platformEnvSchema, resolveBlobCapability, resolveBundleId, } from "./platformKernel.js";

package/dist/kernel/platformKernel.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { type PlatformBundleDescriptor as CorePlatformBundleDescriptor, type PlatformBundleReadiness, type PlatformEnvInput } from "@openlup/core/platform-runtime";
+/** The bundles a deployment can select with `PLATFORM_BUNDLE`. */
+export declare const PLATFORM_BUNDLE_IDS: readonly ["vercel-supabase", "node-supabase", "node-postgres"];
+export type PlatformBundleId = (typeof PLATFORM_BUNDLE_IDS)[number];
+/** The bundle selected when `PLATFORM_BUNDLE` is absent or unknown. */
+export declare const DEFAULT_PLATFORM_BUNDLE: PlatformBundleId;
+export declare const isPlatformBundleId: import("@openlup/core/platform-runtime").PlatformBundleIdGuard<"vercel-supabase" | "node-supabase" | "node-postgres">;
+export type PlatformBundleDescriptor = CorePlatformBundleDescriptor & {
+    id: PlatformBundleId;
+};
+export type { PlatformBundleReadiness };
+/** The readiness code a bundle reports when a selected capability lacks its configuration. */
+export declare const ENV_MISSING_CODE = "OPENLUP_E_ENV_MISSING";
+/** The blob capabilities a deployment can select with `PLATFORM_BLOB`. */
+export declare const BLOB_CAPABILITIES: readonly ["filesystem", "s3", "supabase", "vercel-blob"];
+export type BlobCapability = (typeof BLOB_CAPABILITIES)[number];
+/**
+ * The blob capability in effect: a valid `PLATFORM_BLOB` selection, else the bundle's own. An
+ * invalid selection keeps the bundle's own here and is refused by readiness.
+ */
+export declare function resolveBlobCapability(descriptor: Pick<PlatformBundleDescriptor, "capabilities">, env: PlatformEnvInput): string;
+export declare const PLATFORM_BUNDLE_DESCRIPTORS: readonly PlatformBundleDescriptor[];
+export declare function getBundleDescriptor(id: PlatformBundleId): PlatformBundleDescriptor;
+export declare function resolveBundleId(env: PlatformEnvInput): PlatformBundleId;
+export declare const platformEnvSchema: z.ZodObject<{
+    APP_BASE_URL: z.ZodOptional<z.ZodString>;
+    PLATFORM_BUNDLE: z.ZodOptional<z.ZodEnum<{
+        "vercel-supabase": "vercel-supabase";
+        "node-supabase": "node-supabase";
+        "node-postgres": "node-postgres";
+    }>>;
+}, z.core.$strip>;
+export type PlatformEnv = z.infer<typeof platformEnvSchema>;