@voyant-travel/action-ledger 0.104.10

package/dist/schema.d.ts.map

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

package/dist/schema.js

@@ -0,0 +1,237 @@
+import { typeId } from "@voyant-travel/db/lib/typeid-column";
+import { sql } from "drizzle-orm";
+import { boolean, index, integer, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+export const actionLedgerActionKindEnum = pgEnum("action_ledger_action_kind", [
+    "read",
+    "create",
+    "update",
+    "delete",
+    "execute",
+    "approve",
+    "reject",
+    "reverse",
+    "compensate",
+    "duplicate",
+]);
+export const actionLedgerStatusEnum = pgEnum("action_ledger_status", [
+    "requested",
+    "awaiting_approval",
+    "approved",
+    "denied",
+    "succeeded",
+    "failed",
+    "reversed",
+    "compensated",
+    "expired",
+    "cancelled",
+    "superseded",
+]);
+export const actionLedgerRiskEnum = pgEnum("action_ledger_risk", [
+    "low",
+    "medium",
+    "high",
+    "critical",
+]);
+export const actionLedgerPrincipalTypeEnum = pgEnum("action_ledger_principal_type", [
+    "user",
+    "api_key",
+    "agent",
+    "workflow",
+    "system",
+]);
+export const actionLedgerRelayStatusEnum = pgEnum("action_ledger_relay_status", [
+    "pending",
+    "processing",
+    "succeeded",
+    "failed",
+    "dead_letter",
+]);
+export const actionLedgerRedactionStatusEnum = pgEnum("action_ledger_redaction_status", [
+    "none",
+    "redacted",
+    "tombstoned",
+    "crypto_shredded",
+]);
+export const actionLedgerApprovalStatusEnum = pgEnum("action_ledger_approval_status", [
+    "pending",
+    "approved",
+    "denied",
+    "expired",
+    "cancelled",
+    "superseded",
+]);
+export const actionLedgerReversalKindEnum = pgEnum("action_ledger_reversal_kind", [
+    "none",
+    "revert",
+    "compensate",
+    "domain_command",
+]);
+export const actionLedgerReversalStateEnum = pgEnum("action_ledger_reversal_state", [
+    "not_reversible",
+    "available",
+    "requested",
+    "running",
+    "completed",
+    "failed",
+    "expired",
+]);
+export const actionLedgerReversalOutcomeEnum = pgEnum("action_ledger_reversal_outcome", [
+    "full",
+    "partial",
+    "failed",
+]);
+export const actionLedgerEntries = pgTable("action_ledger_entries", {
+    id: typeId("action_ledger_entries"),
+    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull().defaultNow(),
+    actionName: text("action_name").notNull(),
+    actionVersion: text("action_version").notNull(),
+    actionKind: actionLedgerActionKindEnum("action_kind").notNull(),
+    status: actionLedgerStatusEnum("status").notNull(),
+    evaluatedRisk: actionLedgerRiskEnum("evaluated_risk").notNull(),
+    actorType: text("actor_type"),
+    principalType: actionLedgerPrincipalTypeEnum("principal_type").notNull(),
+    principalId: text("principal_id").notNull(),
+    principalSubtype: text("principal_subtype"),
+    sessionId: text("session_id"),
+    apiTokenId: text("api_token_id"),
+    internalRequest: boolean("internal_request").notNull().default(false),
+    delegatedByPrincipalType: actionLedgerPrincipalTypeEnum("delegated_by_principal_type"),
+    delegatedByPrincipalId: text("delegated_by_principal_id"),
+    delegationId: text("delegation_id"),
+    callerType: text("caller_type"),
+    organizationId: text("organization_id"),
+    routeOrToolName: text("route_or_tool_name"),
+    workflowRunId: text("workflow_run_id"),
+    workflowStepId: text("workflow_step_id"),
+    correlationId: text("correlation_id"),
+    causationActionId: text("causation_action_id"),
+    idempotencyScope: text("idempotency_scope"),
+    idempotencyKey: text("idempotency_key"),
+    idempotencyFingerprint: text("idempotency_fingerprint"),
+    targetType: text("target_type").notNull(),
+    targetId: text("target_id").notNull(),
+    capabilityId: text("capability_id"),
+    capabilityVersion: text("capability_version"),
+    authorizationSource: text("authorization_source"),
+    approvalId: text("approval_id"),
+    amendsActionId: text("amends_action_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_action_ledger_entries_principal").on(table.principalType, table.principalId, table.occurredAt),
+    index("idx_action_ledger_entries_api_token").on(table.apiTokenId, table.occurredAt),
+    index("idx_action_ledger_entries_session").on(table.sessionId, table.occurredAt),
+    index("idx_action_ledger_entries_target").on(table.targetType, table.targetId, table.occurredAt),
+    index("idx_action_ledger_entries_workflow").on(table.workflowRunId, table.workflowStepId, table.occurredAt),
+    index("idx_action_ledger_entries_correlation").on(table.correlationId, table.occurredAt),
+    index("idx_action_ledger_entries_causation").on(table.causationActionId),
+    index("idx_action_ledger_entries_control_state").on(table.evaluatedRisk, table.status, table.occurredAt),
+    index("idx_action_ledger_entries_capability").on(table.capabilityId, table.capabilityVersion, table.occurredAt),
+    uniqueIndex("idx_action_ledger_entries_idempotency")
+        .on(table.idempotencyScope, table.actionName, table.targetType, table.targetId, table.idempotencyKey)
+        .where(sql `
+        ${table.idempotencyKey} IS NOT NULL
+      `),
+]);
+export const actionLedgerRelayOutbox = pgTable("action_ledger_outbox", {
+    id: typeId("action_ledger_outbox"),
+    actionId: text("action_id")
+        .notNull()
+        .references(() => actionLedgerEntries.id, { onDelete: "cascade" }),
+    organizationId: text("organization_id"),
+    relayStatus: actionLedgerRelayStatusEnum("relay_status").notNull().default("pending"),
+    payloadRef: text("payload_ref"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    nextRetryAt: timestamp("next_retry_at", { withTimezone: true }),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    processedAt: timestamp("processed_at", { withTimezone: true }),
+}, (table) => [
+    index("idx_action_ledger_outbox_action").on(table.actionId),
+    index("idx_action_ledger_outbox_status_retry").on(table.relayStatus, table.nextRetryAt),
+]);
+export const actionDelegations = pgTable("action_delegations", {
+    id: typeId("action_delegations"),
+    rootPrincipalType: actionLedgerPrincipalTypeEnum("root_principal_type").notNull(),
+    rootPrincipalId: text("root_principal_id").notNull(),
+    parentPrincipalType: actionLedgerPrincipalTypeEnum("parent_principal_type").notNull(),
+    parentPrincipalId: text("parent_principal_id").notNull(),
+    childPrincipalType: actionLedgerPrincipalTypeEnum("child_principal_type").notNull(),
+    childPrincipalId: text("child_principal_id").notNull(),
+    grantSource: text("grant_source").notNull(),
+    capabilityScopeRef: text("capability_scope_ref"),
+    budgetScopeRef: text("budget_scope_ref"),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_action_delegations_root").on(table.rootPrincipalType, table.rootPrincipalId),
+    index("idx_action_delegations_child").on(table.childPrincipalType, table.childPrincipalId),
+    index("idx_action_delegations_parent").on(table.parentPrincipalType, table.parentPrincipalId),
+]);
+export const actionMutationDetails = pgTable("action_mutation_details", {
+    actionId: text("action_id")
+        .primaryKey()
+        .references(() => actionLedgerEntries.id, { onDelete: "cascade" }),
+    commandInputRef: text("command_input_ref"),
+    commandResultRef: text("command_result_ref"),
+    summary: text("summary"),
+    reversalKind: actionLedgerReversalKindEnum("reversal_kind").notNull().default("none"),
+    reversalCommandId: text("reversal_command_id"),
+    reversalCommandVersion: text("reversal_command_version"),
+    reversalArgsRef: text("reversal_args_ref"),
+    reversalStateProjection: actionLedgerReversalStateEnum("reversal_state_projection"),
+    reversalOutcomeProjection: actionLedgerReversalOutcomeEnum("reversal_outcome_projection"),
+    reversesActionId: text("reverses_action_id"),
+    reversedByActionIdProjection: text("reversed_by_action_id_projection"),
+}, (table) => [
+    index("idx_action_mutation_details_reverses").on(table.reversesActionId),
+    index("idx_action_mutation_details_reversal_state").on(table.reversalStateProjection),
+]);
+export const actionSensitiveReadDetails = pgTable("action_sensitive_read_details", {
+    actionId: text("action_id")
+        .primaryKey()
+        .references(() => actionLedgerEntries.id, { onDelete: "cascade" }),
+    reasonCode: text("reason_code"),
+    disclosedFieldSet: jsonb("disclosed_field_set").$type(),
+    disclosureSummary: text("disclosure_summary"),
+    decisionPolicy: text("decision_policy"),
+});
+export const actionApprovals = pgTable("action_approvals", {
+    id: typeId("action_approvals"),
+    requestedActionId: text("requested_action_id")
+        .notNull()
+        .references(() => actionLedgerEntries.id, { onDelete: "cascade" }),
+    status: actionLedgerApprovalStatusEnum("status").notNull().default("pending"),
+    requestedByPrincipalId: text("requested_by_principal_id").notNull(),
+    assignedToPrincipalId: text("assigned_to_principal_id"),
+    decidedByPrincipalId: text("decided_by_principal_id"),
+    delegatedFromPrincipalId: text("delegated_from_principal_id"),
+    policyName: text("policy_name").notNull(),
+    policyVersion: text("policy_version").notNull(),
+    targetSnapshotRef: text("target_snapshot_ref"),
+    riskSnapshot: actionLedgerRiskEnum("risk_snapshot").notNull(),
+    reasonCode: text("reason_code"),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+    decidedAt: timestamp("decided_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_action_approvals_requested_action").on(table.requestedActionId),
+    index("idx_action_approvals_status_expires").on(table.status, table.expiresAt),
+    index("idx_action_approvals_assignee").on(table.assignedToPrincipalId, table.createdAt),
+]);
+export const actionLedgerPayloads = pgTable("action_ledger_payloads", {
+    id: typeId("action_ledger_payloads"),
+    actionId: text("action_id")
+        .notNull()
+        .references(() => actionLedgerEntries.id, { onDelete: "cascade" }),
+    payloadKind: text("payload_kind").notNull(),
+    schemaTag: text("schema_tag").notNull(),
+    redactionStatus: actionLedgerRedactionStatusEnum("redaction_status").notNull().default("none"),
+    retentionPolicy: text("retention_policy").notNull(),
+    storageRef: text("storage_ref").notNull(),
+    hash: text("hash"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expiresAt: timestamp("expires_at", { withTimezone: true }),
+}, (table) => [
+    index("idx_action_ledger_payloads_action").on(table.actionId),
+    index("idx_action_ledger_payloads_expiry").on(table.expiresAt),
+]);

package/dist/service/approval-status.d.ts

@@ -0,0 +1,3 @@
+import type { ApprovalDecisionStatus } from "./types.js";
+export declare function assertApprovalDecisionStatus(status: string): asserts status is ApprovalDecisionStatus;
+//# sourceMappingURL=approval-status.d.ts.map

package/dist/service/approval-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-status.d.ts","sourceRoot":"","sources":["../../src/service/approval-status.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAYxD,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,IAAI,sBAAsB,CAG1C"}

package/dist/service/approval-status.js

@@ -0,0 +1,14 @@
+import { ActionApprovalDecisionStatusError } from "./errors.js";
+const approvalDecisionStatusValues = [
+    "approved",
+    "denied",
+    "expired",
+    "cancelled",
+    "superseded",
+];
+const approvalDecisionStatusSet = new Set(approvalDecisionStatusValues);
+export function assertApprovalDecisionStatus(status) {
+    if (approvalDecisionStatusSet.has(status))
+        return;
+    throw new ActionApprovalDecisionStatusError(status);
+}

package/dist/service/cursors.d.ts

@@ -0,0 +1,22 @@
+import type { ActionApproval, ActionDelegation, ActionLedgerEntry, ActionLedgerRelayOutbox } from "../schema.js";
+declare function normalizeListLimit(limit: number | undefined): number;
+declare function toActionLedgerListCursor(entry: Pick<ActionLedgerEntry, "occurredAt" | "id">): {
+    occurredAt: string;
+    id: string;
+};
+declare function toActionLedgerRelayOutboxListCursor(row: Pick<ActionLedgerRelayOutbox, "createdAt" | "id">): {
+    createdAt: string;
+    id: string;
+};
+declare function toActionApprovalListCursor(row: Pick<ActionApproval, "createdAt" | "id">): {
+    createdAt: string;
+    id: string;
+};
+declare function toActionDelegationListCursor(row: Pick<ActionDelegation, "createdAt" | "id">): {
+    createdAt: string;
+    id: string;
+};
+declare function serializeCursorDate(value: Date | string): string;
+declare function parseCursorDate(value: Date | string): Date;
+export { normalizeListLimit, parseCursorDate, serializeCursorDate, toActionApprovalListCursor, toActionDelegationListCursor, toActionLedgerListCursor, toActionLedgerRelayOutboxListCursor, };
+//# sourceMappingURL=cursors.d.ts.map

package/dist/service/cursors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursors.d.ts","sourceRoot":"","sources":["../../src/service/cursors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACxB,MAAM,cAAc,CAAA;AAKrB,iBAAS,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAI7D;AAED,iBAAS,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,GAAG,IAAI,CAAC;;;EAKpF;AAED,iBAAS,mCAAmC,CAC1C,GAAG,EAAE,IAAI,CAAC,uBAAuB,EAAE,WAAW,GAAG,IAAI,CAAC;;;EAMvD;AAED,iBAAS,0BAA0B,CAAC,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,IAAI,CAAC;;;EAKhF;AAED,iBAAS,4BAA4B,CAAC,GAAG,EAAE,IAAI,CAAC,gBAAgB,EAAE,WAAW,GAAG,IAAI,CAAC;;;EAKpF;AAED,iBAAS,mBAAmB,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CAMzD;AAED,iBAAS,eAAe,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAMnD;AAED,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,0BAA0B,EAC1B,4BAA4B,EAC5B,wBAAwB,EACxB,mCAAmC,GACpC,CAAA"}

package/dist/service/cursors.js

@@ -0,0 +1,48 @@
+const DEFAULT_LIST_LIMIT = 50;
+const MAX_LIST_LIMIT = 200;
+function normalizeListLimit(limit) {
+    if (limit === undefined)
+        return DEFAULT_LIST_LIMIT;
+    if (!Number.isFinite(limit))
+        return DEFAULT_LIST_LIMIT;
+    return Math.min(Math.max(Math.trunc(limit), 1), MAX_LIST_LIMIT);
+}
+function toActionLedgerListCursor(entry) {
+    return {
+        occurredAt: serializeCursorDate(entry.occurredAt),
+        id: entry.id,
+    };
+}
+function toActionLedgerRelayOutboxListCursor(row) {
+    return {
+        createdAt: serializeCursorDate(row.createdAt),
+        id: row.id,
+    };
+}
+function toActionApprovalListCursor(row) {
+    return {
+        createdAt: serializeCursorDate(row.createdAt),
+        id: row.id,
+    };
+}
+function toActionDelegationListCursor(row) {
+    return {
+        createdAt: serializeCursorDate(row.createdAt),
+        id: row.id,
+    };
+}
+function serializeCursorDate(value) {
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error("Action ledger cursor occurredAt must be a valid timestamp");
+    }
+    return date.toISOString();
+}
+function parseCursorDate(value) {
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error("Action ledger cursor occurredAt must be a valid timestamp");
+    }
+    return date;
+}
+export { normalizeListLimit, parseCursorDate, serializeCursorDate, toActionApprovalListCursor, toActionDelegationListCursor, toActionLedgerListCursor, toActionLedgerRelayOutboxListCursor, };

package/dist/service/entries.d.ts

@@ -0,0 +1,9 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type ActionApproval, type ActionLedgerEntry } from "../schema.js";
+import type { AppendActionLedgerEntryInput, AppendActionLedgerEntryResult } from "./types.js";
+export declare function insertEntry(db: AnyDrizzleDb, input: AppendActionLedgerEntryInput): Promise<AppendActionLedgerEntryResult>;
+export declare function findExistingIdempotentEntry(db: AnyDrizzleDb, input: AppendActionLedgerEntryInput): Promise<ActionLedgerEntry | null>;
+export declare function findApprovalForRequestedAction(db: AnyDrizzleDb, requestedActionId: string): Promise<ActionApproval | null>;
+export declare function findApprovalById(db: AnyDrizzleDb, id: string): Promise<ActionApproval | null>;
+export declare function assertSameFingerprint(entry: ActionLedgerEntry, fingerprint: string | null): void;
+//# sourceMappingURL=entries.d.ts.map

package/dist/service/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../src/service/entries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGrD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,iBAAiB,EAOvB,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,4BAA4B,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAA;AAE7F,wBAAsB,WAAW,CAC/B,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,6BAA6B,CAAC,CAgDxC;AAED,wBAAsB,2BAA2B,CAC/C,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,4BAA4B,GAClC,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAkBnC;AAED,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,YAAY,EAChB,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAQhC;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,YAAY,EAChB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAQhC;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAIhG"}

package/dist/service/entries.js

@@ -0,0 +1,75 @@
+import { and, eq } from "drizzle-orm";
+import { actionApprovals, actionLedgerEntries, actionLedgerPayloads, actionLedgerRelayOutbox, actionMutationDetails, actionSensitiveReadDetails, } from "../schema.js";
+import { ActionLedgerIdempotencyConflictError } from "./errors.js";
+export async function insertEntry(db, input) {
+    const { enqueueRelay, mutationDetail, payloads, sensitiveReadDetail, ...entryInput } = input;
+    const [entry] = await db
+        .insert(actionLedgerEntries)
+        .values({
+        ...entryInput,
+        occurredAt: input.occurredAt,
+    })
+        .returning();
+    if (!entry) {
+        throw new Error("Action ledger insert did not return an entry");
+    }
+    if (mutationDetail) {
+        await db.insert(actionMutationDetails).values({
+            actionId: entry.id,
+            ...mutationDetail,
+        });
+    }
+    if (sensitiveReadDetail) {
+        await db.insert(actionSensitiveReadDetails).values({
+            actionId: entry.id,
+            ...sensitiveReadDetail,
+        });
+    }
+    if (payloads && payloads.length > 0) {
+        await db.insert(actionLedgerPayloads).values(payloads.map((payload) => ({
+            actionId: entry.id,
+            ...payload,
+        })));
+    }
+    if (enqueueRelay) {
+        const payloadRef = typeof enqueueRelay === "object" ? enqueueRelay.payloadRef : null;
+        await db.insert(actionLedgerRelayOutbox).values({
+            actionId: entry.id,
+            organizationId: entry.organizationId,
+            payloadRef: payloadRef ?? null,
+            relayStatus: "pending",
+        });
+    }
+    return { entry, replayed: false };
+}
+export async function findExistingIdempotentEntry(db, input) {
+    if (!input.idempotencyScope || !input.idempotencyKey)
+        return null;
+    const [existing] = await db
+        .select()
+        .from(actionLedgerEntries)
+        .where(and(eq(actionLedgerEntries.idempotencyScope, input.idempotencyScope), eq(actionLedgerEntries.actionName, input.actionName), eq(actionLedgerEntries.targetType, input.targetType), eq(actionLedgerEntries.targetId, input.targetId), eq(actionLedgerEntries.idempotencyKey, input.idempotencyKey)))
+        .limit(1);
+    return existing ?? null;
+}
+export async function findApprovalForRequestedAction(db, requestedActionId) {
+    const [approval] = await db
+        .select()
+        .from(actionApprovals)
+        .where(eq(actionApprovals.requestedActionId, requestedActionId))
+        .limit(1);
+    return approval ?? null;
+}
+export async function findApprovalById(db, id) {
+    const [approval] = await db
+        .select()
+        .from(actionApprovals)
+        .where(eq(actionApprovals.id, id))
+        .limit(1);
+    return approval ?? null;
+}
+export function assertSameFingerprint(entry, fingerprint) {
+    if (entry.idempotencyFingerprint !== fingerprint) {
+        throw new ActionLedgerIdempotencyConflictError(entry.id);
+    }
+}

package/dist/service/errors.d.ts

@@ -0,0 +1,20 @@
+import type { ActionApproval } from "../schema.js";
+export declare class ActionLedgerIdempotencyConflictError extends Error {
+    readonly existingActionId: string;
+    constructor(existingActionId: string);
+}
+export declare class ActionApprovalDecisionConflictError extends Error {
+    readonly approvalId: string;
+    readonly currentStatus: ActionApproval["status"];
+    constructor(approvalId: string, currentStatus: ActionApproval["status"]);
+}
+export declare class ActionApprovalDecisionStatusError extends Error {
+    readonly status: string;
+    constructor(status: string);
+}
+export declare class ActionLedgerReversalTargetError extends Error {
+    readonly actionId: string;
+    readonly reason: "missing_mutation_detail" | "not_reversible";
+    constructor(actionId: string, reason: "missing_mutation_detail" | "not_reversible");
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/service/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/service/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,qBAAa,oCAAqC,SAAQ,KAAK;IAC7D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;gBAErB,gBAAgB,EAAE,MAAM;CAKrC;AAED,qBAAa,mCAAoC,SAAQ,KAAK;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,aAAa,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAA;gBAEpC,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc,CAAC,QAAQ,CAAC;CAMxE;AAED,qBAAa,iCAAkC,SAAQ,KAAK;IAC1D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;gBAEX,MAAM,EAAE,MAAM;CAK3B;AAED,qBAAa,+BAAgC,SAAQ,KAAK;IACxD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,yBAAyB,GAAG,gBAAgB,CAAA;gBAEjD,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,yBAAyB,GAAG,gBAAgB;CAMnF"}

package/dist/service/errors.js

@@ -0,0 +1,36 @@
+export class ActionLedgerIdempotencyConflictError extends Error {
+    existingActionId;
+    constructor(existingActionId) {
+        super("Action ledger idempotency key was reused with a different fingerprint");
+        this.name = "ActionLedgerIdempotencyConflictError";
+        this.existingActionId = existingActionId;
+    }
+}
+export class ActionApprovalDecisionConflictError extends Error {
+    approvalId;
+    currentStatus;
+    constructor(approvalId, currentStatus) {
+        super(`Action approval ${approvalId} is already ${currentStatus}`);
+        this.name = "ActionApprovalDecisionConflictError";
+        this.approvalId = approvalId;
+        this.currentStatus = currentStatus;
+    }
+}
+export class ActionApprovalDecisionStatusError extends Error {
+    status;
+    constructor(status) {
+        super(`Action approval decision status must be terminal, received ${status}`);
+        this.name = "ActionApprovalDecisionStatusError";
+        this.status = status;
+    }
+}
+export class ActionLedgerReversalTargetError extends Error {
+    actionId;
+    reason;
+    constructor(actionId, reason) {
+        super(`Action ledger entry ${actionId} cannot be reversed: ${reason}`);
+        this.name = "ActionLedgerReversalTargetError";
+        this.actionId = actionId;
+        this.reason = reason;
+    }
+}

package/dist/service/listing.d.ts

@@ -0,0 +1,7 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { ListActionApprovalsInput, ListActionApprovalsResult, ListActionDelegationsInput, ListActionDelegationsResult, ListActionLedgerEntriesInput, ListActionLedgerEntriesResult, ListActionLedgerRelayOutboxInput, ListActionLedgerRelayOutboxResult } from "./types.js";
+export declare function listEntries(db: AnyDrizzleDb, input?: ListActionLedgerEntriesInput): Promise<ListActionLedgerEntriesResult>;
+export declare function listRelayOutbox(db: AnyDrizzleDb, input?: ListActionLedgerRelayOutboxInput): Promise<ListActionLedgerRelayOutboxResult>;
+export declare function listApprovals(db: AnyDrizzleDb, input?: ListActionApprovalsInput): Promise<ListActionApprovalsResult>;
+export declare function listDelegations(db: AnyDrizzleDb, input?: ListActionDelegationsInput): Promise<ListActionDelegationsResult>;
+//# sourceMappingURL=listing.d.ts.map

package/dist/service/listing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listing.d.ts","sourceRoot":"","sources":["../../src/service/listing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAsBrD,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,YAAY,CAAA;AAEnB,wBAAsB,WAAW,CAC/B,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,4BAAiC,GACvC,OAAO,CAAC,6BAA6B,CAAC,CAsBxC;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,gCAAqC,GAC3C,OAAO,CAAC,iCAAiC,CAAC,CAqB5C;AAED,wBAAsB,aAAa,CACjC,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,wBAA6B,GACnC,OAAO,CAAC,yBAAyB,CAAC,CAqBpC;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,0BAA+B,GACrC,OAAO,CAAC,2BAA2B,CAAC,CAqBtC"}

package/dist/service/listing.js

@@ -0,0 +1,77 @@
+import { asc, desc } from "drizzle-orm";
+import { actionApprovals, actionDelegations, actionLedgerEntries, actionLedgerRelayOutbox, } from "../schema.js";
+import { normalizeListLimit, toActionApprovalListCursor, toActionDelegationListCursor, toActionLedgerListCursor, toActionLedgerRelayOutboxListCursor, } from "./cursors.js";
+import { buildActionApprovalsPredicate, buildActionDelegationsPredicate, buildActionLedgerEntriesPredicate, buildActionLedgerRelayOutboxPredicate, } from "./predicates.js";
+export async function listEntries(db, input = {}) {
+    const limit = normalizeListLimit(input.limit);
+    const predicate = buildActionLedgerEntriesPredicate(input);
+    const direction = input.sortDir === "asc" ? asc : desc;
+    let query = db.select().from(actionLedgerEntries).$dynamic();
+    if (predicate) {
+        query = query.where(predicate);
+    }
+    const rows = await query
+        .orderBy(direction(actionLedgerEntries.occurredAt), direction(actionLedgerEntries.id))
+        .limit(limit + 1);
+    const entries = rows.slice(0, limit);
+    return {
+        entries,
+        nextCursor: rows.length > limit && entries.length > 0
+            ? toActionLedgerListCursor(entries[entries.length - 1])
+            : null,
+    };
+}
+export async function listRelayOutbox(db, input = {}) {
+    const limit = normalizeListLimit(input.limit);
+    const predicate = buildActionLedgerRelayOutboxPredicate(input);
+    let query = db.select().from(actionLedgerRelayOutbox).$dynamic();
+    if (predicate) {
+        query = query.where(predicate);
+    }
+    const rows = await query
+        .orderBy(desc(actionLedgerRelayOutbox.createdAt), desc(actionLedgerRelayOutbox.id))
+        .limit(limit + 1);
+    const visibleRows = rows.slice(0, limit);
+    return {
+        rows: visibleRows,
+        nextCursor: rows.length > limit && visibleRows.length > 0
+            ? toActionLedgerRelayOutboxListCursor(visibleRows[visibleRows.length - 1])
+            : null,
+    };
+}
+export async function listApprovals(db, input = {}) {
+    const limit = normalizeListLimit(input.limit);
+    const predicate = buildActionApprovalsPredicate(input);
+    let query = db.select().from(actionApprovals).$dynamic();
+    if (predicate) {
+        query = query.where(predicate);
+    }
+    const rows = await query
+        .orderBy(desc(actionApprovals.createdAt), desc(actionApprovals.id))
+        .limit(limit + 1);
+    const approvals = rows.slice(0, limit);
+    return {
+        approvals,
+        nextCursor: rows.length > limit && approvals.length > 0
+            ? toActionApprovalListCursor(approvals[approvals.length - 1])
+            : null,
+    };
+}
+export async function listDelegations(db, input = {}) {
+    const limit = normalizeListLimit(input.limit);
+    const predicate = buildActionDelegationsPredicate(input);
+    let query = db.select().from(actionDelegations).$dynamic();
+    if (predicate) {
+        query = query.where(predicate);
+    }
+    const rows = await query
+        .orderBy(desc(actionDelegations.createdAt), desc(actionDelegations.id))
+        .limit(limit + 1);
+    const delegations = rows.slice(0, limit);
+    return {
+        delegations,
+        nextCursor: rows.length > limit && delegations.length > 0
+            ? toActionDelegationListCursor(delegations[delegations.length - 1])
+            : null,
+    };
+}

package/dist/service/predicates.d.ts

@@ -0,0 +1,8 @@
+import { type SQL } from "drizzle-orm";
+import type { ListActionApprovalsInput, ListActionDelegationsInput, ListActionLedgerEntriesInput, ListActionLedgerRelayOutboxInput } from "./types.js";
+declare function buildActionDelegationsPredicate(input: ListActionDelegationsInput): SQL | undefined;
+declare function buildActionApprovalsPredicate(input: ListActionApprovalsInput): SQL | undefined;
+declare function buildActionLedgerRelayOutboxPredicate(input: ListActionLedgerRelayOutboxInput): SQL | undefined;
+declare function buildActionLedgerEntriesPredicate(input: ListActionLedgerEntriesInput): SQL | undefined;
+export { buildActionApprovalsPredicate, buildActionDelegationsPredicate, buildActionLedgerEntriesPredicate, buildActionLedgerRelayOutboxPredicate, };
+//# sourceMappingURL=predicates.d.ts.map

package/dist/service/predicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicates.d.ts","sourceRoot":"","sources":["../../src/service/predicates.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0C,KAAK,GAAG,EAAO,MAAM,aAAa,CAAA;AAenF,OAAO,KAAK,EAKV,wBAAwB,EACxB,0BAA0B,EAC1B,4BAA4B,EAC5B,gCAAgC,EACjC,MAAM,YAAY,CAAA;AAiKnB,iBAAS,+BAA+B,CAAC,KAAK,EAAE,0BAA0B,GAAG,GAAG,GAAG,SAAS,CAiD3F;AAED,iBAAS,6BAA6B,CAAC,KAAK,EAAE,wBAAwB,GAAG,GAAG,GAAG,SAAS,CAwDvF;AAED,iBAAS,qCAAqC,CAC5C,KAAK,EAAE,gCAAgC,GACtC,GAAG,GAAG,SAAS,CAqCjB;AAED,iBAAS,iCAAiC,CAAC,KAAK,EAAE,4BAA4B,GAAG,GAAG,GAAG,SAAS,CAoH/F;AAED,OAAO,EACL,6BAA6B,EAC7B,+BAA+B,EAC/B,iCAAiC,EACjC,qCAAqC,GACtC,CAAA"}