@treeseed/sdk 0.13.0-rc.11 → 0.13.0-rc.111

package/dist/deployment/postgres/contracts.d.ts

@@ -0,0 +1,418 @@
+import { z } from 'zod';
+/** Package-owned requirements, not an instruction to start another server. */
+export declare const postgresRequirementSchema: z.ZodObject<{
+    id: z.ZodString;
+    componentId: z.ZodString;
+    enabled: z.ZodBoolean;
+    supportedMajors: z.ZodEffects<z.ZodArray<z.ZodNumber, "atleastone">, [number, ...number[]], [number, ...number[]]>;
+    extensions: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+    runtimeConnectionLimit: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    enabled: boolean;
+    componentId: string;
+    supportedMajors: [number, ...number[]];
+    extensions: string[];
+    runtimeConnectionLimit: number;
+}, {
+    id: string;
+    enabled: boolean;
+    componentId: string;
+    supportedMajors: [number, ...number[]];
+    extensions: string[];
+    runtimeConnectionLimit: number;
+}>;
+/** Immutable component requirement. Installation activation supplies componentId/enabled. */
+export declare const postgresComponentRequirementSchema: z.ZodObject<Omit<{
+    id: z.ZodString;
+    componentId: z.ZodString;
+    enabled: z.ZodBoolean;
+    supportedMajors: z.ZodEffects<z.ZodArray<z.ZodNumber, "atleastone">, [number, ...number[]], [number, ...number[]]>;
+    extensions: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+    runtimeConnectionLimit: z.ZodNumber;
+}, "enabled" | "componentId">, "strict", z.ZodTypeAny, {
+    id: string;
+    supportedMajors: [number, ...number[]];
+    extensions: string[];
+    runtimeConnectionLimit: number;
+}, {
+    id: string;
+    supportedMajors: [number, ...number[]];
+    extensions: string[];
+    runtimeConnectionLimit: number;
+}>;
+/** Deployment owns the selected server and its bootstrap authority. No credentials here. */
+export declare const postgresServerSchema: z.ZodObject<{
+    id: z.ZodString;
+    installationId: z.ZodString;
+    environment: z.ZodEnum<["staging", "production"]>;
+    mode: z.ZodEnum<["shared", "dedicated", "external"]>;
+    hostname: z.ZodString;
+    port: z.ZodNumber;
+    major: z.ZodNumber;
+    extensions: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+    tls: z.ZodObject<{
+        mode: z.ZodLiteral<"verify-full">;
+        trustReference: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        mode: "verify-full";
+        trustReference: string;
+    }, {
+        mode: "verify-full";
+        trustReference: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    mode: "shared" | "dedicated" | "external";
+    environment: "production" | "staging";
+    port: number;
+    major: number;
+    extensions: string[];
+    installationId: string;
+    hostname: string;
+    tls: {
+        mode: "verify-full";
+        trustReference: string;
+    };
+}, {
+    id: string;
+    mode: "shared" | "dedicated" | "external";
+    environment: "production" | "staging";
+    port: number;
+    major: number;
+    extensions: string[];
+    installationId: string;
+    hostname: string;
+    tls: {
+        mode: "verify-full";
+        trustReference: string;
+    };
+}>;
+export declare const postgresAllocationSchema: z.ZodEffects<z.ZodObject<{
+    requirementId: z.ZodString;
+    serverId: z.ZodString;
+    database: z.ZodEffects<z.ZodString, string, string>;
+    ownerRole: z.ZodEffects<z.ZodString, string, string>;
+    migrationRole: z.ZodEffects<z.ZodString, string, string>;
+    runtimeRole: z.ZodEffects<z.ZodString, string, string>;
+    migrationCredentialReference: z.ZodString;
+    runtimeCredentialReference: z.ZodString;
+    onDisable: z.ZodLiteral<"preserve">;
+}, "strict", z.ZodTypeAny, {
+    requirementId: string;
+    serverId: string;
+    database: string;
+    ownerRole: string;
+    migrationRole: string;
+    runtimeRole: string;
+    migrationCredentialReference: string;
+    runtimeCredentialReference: string;
+    onDisable: "preserve";
+}, {
+    requirementId: string;
+    serverId: string;
+    database: string;
+    ownerRole: string;
+    migrationRole: string;
+    runtimeRole: string;
+    migrationCredentialReference: string;
+    runtimeCredentialReference: string;
+    onDisable: "preserve";
+}>, {
+    requirementId: string;
+    serverId: string;
+    database: string;
+    ownerRole: string;
+    migrationRole: string;
+    runtimeRole: string;
+    migrationCredentialReference: string;
+    runtimeCredentialReference: string;
+    onDisable: "preserve";
+}, {
+    requirementId: string;
+    serverId: string;
+    database: string;
+    ownerRole: string;
+    migrationRole: string;
+    runtimeRole: string;
+    migrationCredentialReference: string;
+    runtimeCredentialReference: string;
+    onDisable: "preserve";
+}>;
+/** One installation/environment. Explicit allocations may select dedicated servers. */
+export declare const postgresTopologySchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.postgres-topology/v1">;
+    installationId: z.ZodString;
+    environment: z.ZodEnum<["staging", "production"]>;
+    servers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        installationId: z.ZodString;
+        environment: z.ZodEnum<["staging", "production"]>;
+        mode: z.ZodEnum<["shared", "dedicated", "external"]>;
+        hostname: z.ZodString;
+        port: z.ZodNumber;
+        major: z.ZodNumber;
+        extensions: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+        tls: z.ZodObject<{
+            mode: z.ZodLiteral<"verify-full">;
+            trustReference: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            mode: "verify-full";
+            trustReference: string;
+        }, {
+            mode: "verify-full";
+            trustReference: string;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        mode: "shared" | "dedicated" | "external";
+        environment: "production" | "staging";
+        port: number;
+        major: number;
+        extensions: string[];
+        installationId: string;
+        hostname: string;
+        tls: {
+            mode: "verify-full";
+            trustReference: string;
+        };
+    }, {
+        id: string;
+        mode: "shared" | "dedicated" | "external";
+        environment: "production" | "staging";
+        port: number;
+        major: number;
+        extensions: string[];
+        installationId: string;
+        hostname: string;
+        tls: {
+            mode: "verify-full";
+            trustReference: string;
+        };
+    }>, "many">;
+    requirements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        componentId: z.ZodString;
+        enabled: z.ZodBoolean;
+        supportedMajors: z.ZodEffects<z.ZodArray<z.ZodNumber, "atleastone">, [number, ...number[]], [number, ...number[]]>;
+        extensions: z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>;
+        runtimeConnectionLimit: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }, {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }>, "many">;
+    allocations: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        requirementId: z.ZodString;
+        serverId: z.ZodString;
+        database: z.ZodEffects<z.ZodString, string, string>;
+        ownerRole: z.ZodEffects<z.ZodString, string, string>;
+        migrationRole: z.ZodEffects<z.ZodString, string, string>;
+        runtimeRole: z.ZodEffects<z.ZodString, string, string>;
+        migrationCredentialReference: z.ZodString;
+        runtimeCredentialReference: z.ZodString;
+        onDisable: z.ZodLiteral<"preserve">;
+    }, "strict", z.ZodTypeAny, {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }, {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }>, {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }, {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.postgres-topology/v1";
+    environment: "production" | "staging";
+    installationId: string;
+    servers: {
+        id: string;
+        mode: "shared" | "dedicated" | "external";
+        environment: "production" | "staging";
+        port: number;
+        major: number;
+        extensions: string[];
+        installationId: string;
+        hostname: string;
+        tls: {
+            mode: "verify-full";
+            trustReference: string;
+        };
+    }[];
+    requirements: {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }[];
+    allocations: {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }[];
+}, {
+    schemaVersion: "treeseed.postgres-topology/v1";
+    environment: "production" | "staging";
+    installationId: string;
+    servers: {
+        id: string;
+        mode: "shared" | "dedicated" | "external";
+        environment: "production" | "staging";
+        port: number;
+        major: number;
+        extensions: string[];
+        installationId: string;
+        hostname: string;
+        tls: {
+            mode: "verify-full";
+            trustReference: string;
+        };
+    }[];
+    requirements: {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }[];
+    allocations: {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }[];
+}>, {
+    schemaVersion: "treeseed.postgres-topology/v1";
+    environment: "production" | "staging";
+    installationId: string;
+    servers: {
+        id: string;
+        mode: "shared" | "dedicated" | "external";
+        environment: "production" | "staging";
+        port: number;
+        major: number;
+        extensions: string[];
+        installationId: string;
+        hostname: string;
+        tls: {
+            mode: "verify-full";
+            trustReference: string;
+        };
+    }[];
+    requirements: {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }[];
+    allocations: {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }[];
+}, {
+    schemaVersion: "treeseed.postgres-topology/v1";
+    environment: "production" | "staging";
+    installationId: string;
+    servers: {
+        id: string;
+        mode: "shared" | "dedicated" | "external";
+        environment: "production" | "staging";
+        port: number;
+        major: number;
+        extensions: string[];
+        installationId: string;
+        hostname: string;
+        tls: {
+            mode: "verify-full";
+            trustReference: string;
+        };
+    }[];
+    requirements: {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }[];
+    allocations: {
+        requirementId: string;
+        serverId: string;
+        database: string;
+        ownerRole: string;
+        migrationRole: string;
+        runtimeRole: string;
+        migrationCredentialReference: string;
+        runtimeCredentialReference: string;
+        onDisable: "preserve";
+    }[];
+}>;
+export type PostgresRequirement = z.infer<typeof postgresRequirementSchema>;
+export type PostgresServer = z.infer<typeof postgresServerSchema>;
+export type PostgresAllocation = z.infer<typeof postgresAllocationSchema>;
+export type PostgresTopology = z.infer<typeof postgresTopologySchema>;

package/dist/deployment/postgres/contracts.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+const id = z.string().regex(/^[a-z][a-z0-9-]{0,62}$/u);
+const sqlName = z.string().regex(/^[a-z][a-z0-9_]{0,62}$/u).refine((value) => value !== "postgres" && !value.startsWith("pg_"), "Application identifiers must not use PostgreSQL administrative names.");
+const unique = (values) => new Set(values).size === values.length;
+const postgresRequirementSchema = z.object({
+  id,
+  componentId: id,
+  enabled: z.boolean(),
+  supportedMajors: z.array(z.number().int().min(14).max(99)).nonempty().refine(unique),
+  extensions: z.array(sqlName).refine(unique),
+  runtimeConnectionLimit: z.number().int().min(1).max(1e3)
+}).strict();
+const postgresComponentRequirementSchema = postgresRequirementSchema.omit({ componentId: true, enabled: true });
+const postgresServerSchema = z.object({
+  id,
+  installationId: id,
+  environment: z.enum(["staging", "production"]),
+  mode: z.enum(["shared", "dedicated", "external"]),
+  hostname: z.string().max(253).regex(/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/u),
+  port: z.number().int().min(1).max(65535),
+  major: z.number().int().min(14).max(99),
+  extensions: z.array(sqlName).refine(unique),
+  tls: z.object({ mode: z.literal("verify-full"), trustReference: id }).strict()
+}).strict();
+const postgresAllocationSchema = z.object({
+  requirementId: id,
+  serverId: id,
+  database: sqlName,
+  ownerRole: sqlName,
+  migrationRole: sqlName,
+  runtimeRole: sqlName,
+  migrationCredentialReference: id,
+  runtimeCredentialReference: id,
+  onDisable: z.literal("preserve")
+}).strict().superRefine((value, context) => {
+  if (!unique([value.ownerRole, value.migrationRole, value.runtimeRole])) context.addIssue({ code: z.ZodIssueCode.custom, message: "Owner, migration and runtime roles must be distinct." });
+  if (value.migrationCredentialReference === value.runtimeCredentialReference) context.addIssue({ code: z.ZodIssueCode.custom, message: "Migration and runtime credentials must be distinct." });
+});
+const postgresTopologySchema = z.object({
+  schemaVersion: z.literal("treeseed.postgres-topology/v1"),
+  installationId: id,
+  environment: z.enum(["staging", "production"]),
+  servers: z.array(postgresServerSchema),
+  requirements: z.array(postgresRequirementSchema),
+  allocations: z.array(postgresAllocationSchema)
+}).strict().superRefine((value, context) => {
+  const fail = (message) => context.addIssue({ code: z.ZodIssueCode.custom, message });
+  if (!unique(value.servers.map((server) => server.id)) || !unique(value.requirements.map((requirement) => requirement.id)) || !unique(value.allocations.map((allocation) => allocation.requirementId))) fail("Server, requirement and allocation identities must be unique.");
+  if (value.servers.filter((server) => server.mode === "shared").length > 1) fail("An environment has at most one default shared server.");
+  if (value.servers.some((server) => server.installationId !== value.installationId || server.environment !== value.environment)) fail("Servers must belong to this installation and environment.");
+  const databases = /* @__PURE__ */ new Set(), roles = /* @__PURE__ */ new Set(), credentials = /* @__PURE__ */ new Set();
+  for (const allocation of value.allocations) {
+    const server = value.servers.find((entry) => entry.id === allocation.serverId);
+    const requirement = value.requirements.find((entry) => entry.id === allocation.requirementId);
+    if (!server || !requirement) {
+      fail("Allocation references an unknown server or requirement.");
+      continue;
+    }
+    if (!requirement.supportedMajors.includes(server.major) || requirement.extensions.some((extension) => !server.extensions.includes(extension))) fail("Server does not satisfy package version/extension requirements.");
+    const databaseKey = `${server.id}:${allocation.database}`;
+    if (databases.has(databaseKey)) fail("Applications must not share an allocated database.");
+    databases.add(databaseKey);
+    for (const reference of [allocation.migrationCredentialReference, allocation.runtimeCredentialReference]) {
+      if (credentials.has(reference)) fail("Applications must not share database credential references.");
+      credentials.add(reference);
+    }
+    for (const role of [allocation.ownerRole, allocation.migrationRole, allocation.runtimeRole]) {
+      const key = `${server.id}:${role}`;
+      if (roles.has(key)) fail("Applications must not share database roles.");
+      roles.add(key);
+    }
+  }
+  for (const requirement of value.requirements) {
+    if (requirement.enabled && !value.allocations.some((allocation) => allocation.requirementId === requirement.id)) fail("Enabled database requirements need explicit allocations.");
+  }
+});
+export {
+  postgresAllocationSchema,
+  postgresComponentRequirementSchema,
+  postgresRequirementSchema,
+  postgresServerSchema,
+  postgresTopologySchema
+};

package/dist/deployment/postgres/requirements.d.ts

@@ -0,0 +1,14 @@
+/** Call after artifact authenticity verification, with the complete selected
+ * component inventory. Host configuration cannot weaken a package requirement.
+ */
+export declare function verifyHostPostgresRequirements(hostInput: unknown, releaseInputs: unknown[]): {
+    verified: true;
+    requirements: {
+        id: string;
+        enabled: boolean;
+        componentId: string;
+        supportedMajors: [number, ...number[]];
+        extensions: string[];
+        runtimeConnectionLimit: number;
+    }[];
+};

package/dist/deployment/postgres/requirements.js

@@ -0,0 +1,30 @@
+import { componentReleaseSchema, hostConfigurationSchema } from "../schemas.js";
+import { canonicalDeploymentJson, deploymentDigest } from "../canonical.js";
+function verifyHostPostgresRequirements(hostInput, releaseInputs) {
+  const host = hostConfigurationSchema.parse(hostInput);
+  const releases = releaseInputs.map((input) => componentReleaseSchema.parse(input));
+  if (new Set(releases.map((item) => item.componentId)).size !== releases.length) throw new Error("Duplicate component release inventory");
+  if (Object.entries(host.components).some(([id, selection]) => selection.enabled && !releases.some((release) => release.componentId === id))) throw new Error("Selected component release inventory is incomplete");
+  const requirements = [];
+  for (const release of releases) {
+    const selection = host.components[release.componentId];
+    if (!selection) continue;
+    if (deploymentDigest(release.runtime) !== release.runtimeDigest) throw new Error("Component runtime digest mismatch");
+    for (const requirement of release.runtime.postgresRequirements ?? []) requirements.push({
+      ...requirement,
+      componentId: release.componentId,
+      enabled: selection.enabled
+    });
+  }
+  if (new Set(requirements.map((item) => item.id)).size !== requirements.length) throw new Error("Component database requirement identities collide");
+  const normalize = (items) => items.map((item) => ({
+    ...item,
+    supportedMajors: [...item.supportedMajors].sort((a, b) => a - b),
+    extensions: [...item.extensions].sort()
+  })).sort((a, b) => a.id.localeCompare(b.id));
+  if (canonicalDeploymentJson(normalize(requirements)) !== canonicalDeploymentJson(normalize(host.postgres?.requirements ?? []))) throw new Error("Host database requirements differ from selected immutable components");
+  return { verified: true, requirements };
+}
+export {
+  verifyHostPostgresRequirements
+};

package/dist/deployment/postgres/transfer.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+/** Exact future activation selection, not permission to execute caller SQL or
+ * restart a source database. Deployment reattests retained source custody and
+ * performs transfer only inside coordinated backup/reconciliation. */
+export declare const postgresTransitionSelectionSchema: z.ZodEffects<z.ZodObject<{
+    componentId: z.ZodString;
+    sourceRuntimeDigest: z.ZodString;
+    targetRuntimeDigest: z.ZodString;
+    topologyDigest: z.ZodString;
+    configurationDigest: z.ZodString;
+    allowLocaleConversion: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    configurationDigest: string;
+    componentId: string;
+    sourceRuntimeDigest: string;
+    targetRuntimeDigest: string;
+    topologyDigest: string;
+    allowLocaleConversion: boolean;
+}, {
+    configurationDigest: string;
+    componentId: string;
+    sourceRuntimeDigest: string;
+    targetRuntimeDigest: string;
+    topologyDigest: string;
+    allowLocaleConversion: boolean;
+}>, {
+    configurationDigest: string;
+    componentId: string;
+    sourceRuntimeDigest: string;
+    targetRuntimeDigest: string;
+    topologyDigest: string;
+    allowLocaleConversion: boolean;
+}, {
+    configurationDigest: string;
+    componentId: string;
+    sourceRuntimeDigest: string;
+    targetRuntimeDigest: string;
+    topologyDigest: string;
+    allowLocaleConversion: boolean;
+}>;
+export type PostgresTransitionSelection = z.infer<typeof postgresTransitionSelectionSchema>;
+export declare const postgresTransferPreparationResultSchema: z.ZodObject<{
+    action: z.ZodEnum<["planned", "prepared", "noop"]>;
+    selectionDigest: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    action: "noop" | "planned" | "prepared";
+    selectionDigest: string;
+}, {
+    action: "noop" | "planned" | "prepared";
+    selectionDigest: string;
+}>;
+/** Redacted durable status: no database contents, connection settings, paths,
+ * credentials or process output. A held transfer requires coordinated restore. */
+export declare const postgresTransferRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.postgres-transfer-journal/v1">;
+    intentDigest: z.ZodString;
+    restoreGeneration: z.ZodNumber;
+    restoreDigest: z.ZodString;
+    stage: z.ZodEnum<["fencing", "export", "restore", "verify", "switch", "activate", "accepted", "recovery-required", "rolled-back"]>;
+    archiveDigest: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.postgres-transfer-journal/v1";
+    intentDigest: string;
+    restoreGeneration: number;
+    restoreDigest: string;
+    stage: "verify" | "rolled-back" | "restore" | "fencing" | "export" | "switch" | "activate" | "accepted" | "recovery-required";
+    archiveDigest?: string | undefined;
+}, {
+    schemaVersion: "treeseed.postgres-transfer-journal/v1";
+    intentDigest: string;
+    restoreGeneration: number;
+    restoreDigest: string;
+    stage: "verify" | "rolled-back" | "restore" | "fencing" | "export" | "switch" | "activate" | "accepted" | "recovery-required";
+    archiveDigest?: string | undefined;
+}>;
+export declare const postgresTransferStatusSchema: z.ZodNullable<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"treeseed.postgres-transfer-journal/v1">;
+    intentDigest: z.ZodString;
+    restoreGeneration: z.ZodNumber;
+    restoreDigest: z.ZodString;
+    stage: z.ZodEnum<["fencing", "export", "restore", "verify", "switch", "activate", "accepted", "recovery-required", "rolled-back"]>;
+    archiveDigest: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: "treeseed.postgres-transfer-journal/v1";
+    intentDigest: string;
+    restoreGeneration: number;
+    restoreDigest: string;
+    stage: "verify" | "rolled-back" | "restore" | "fencing" | "export" | "switch" | "activate" | "accepted" | "recovery-required";
+    archiveDigest?: string | undefined;
+}, {
+    schemaVersion: "treeseed.postgres-transfer-journal/v1";
+    intentDigest: string;
+    restoreGeneration: number;
+    restoreDigest: string;
+    stage: "verify" | "rolled-back" | "restore" | "fencing" | "export" | "switch" | "activate" | "accepted" | "recovery-required";
+    archiveDigest?: string | undefined;
+}>>;

package/dist/deployment/postgres/transfer.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const postgresTransitionSelectionSchema = z.object({
+  componentId: z.string().regex(/^[a-z][a-z0-9.-]{0,127}$/u),
+  sourceRuntimeDigest: digest,
+  targetRuntimeDigest: digest,
+  topologyDigest: digest,
+  configurationDigest: digest,
+  allowLocaleConversion: z.boolean()
+}).strict().refine((value) => value.sourceRuntimeDigest !== value.targetRuntimeDigest, "Distinct source and target runtimes required");
+const postgresTransferPreparationResultSchema = z.object({
+  action: z.enum(["planned", "prepared", "noop"]),
+  selectionDigest: digest
+}).strict();
+const postgresTransferRecordSchema = z.object({
+  schemaVersion: z.literal("treeseed.postgres-transfer-journal/v1"),
+  intentDigest: digest,
+  restoreGeneration: z.number().int().positive().safe(),
+  restoreDigest: digest,
+  stage: z.enum(["fencing", "export", "restore", "verify", "switch", "activate", "accepted", "recovery-required", "rolled-back"]),
+  archiveDigest: digest.optional()
+}).strict();
+const postgresTransferStatusSchema = postgresTransferRecordSchema.nullable();
+export {
+  postgresTransferPreparationResultSchema,
+  postgresTransferRecordSchema,
+  postgresTransferStatusSchema,
+  postgresTransitionSelectionSchema
+};