@wtfalch/foundry 0.64.0 → 0.65.0

package/dist/plan/executor.d.ts

@@ -1765,7 +1765,7 @@ export interface FoundryStepExecutorPorts {
     /**
      * The stage copy (`copy_prod_to_stage`, run by the release tick). The host supplies the dump download and the
      * backup storage; foundry builds the restore port itself and reads production's address live from Coolify.
-     * Without it a copy request is refused with `no-copy-port`. The host needs `pg_restore` (Postgres 16) on PATH.
+     * Without it a copy request is refused with `no-copy-port`. The host needs `pg_restore` on PATH, of the production database's Postgres version or newer (platform-archon-db runs 18).
      */
     stageCopy?: StageCopyHostConfig;
     /**

package/dist/plan/platform-providers.js

@@ -6237,7 +6237,7 @@ function assertSameDatabaseHost(key, liveUrl, dbInternalUrl) {
 /**
  * Throws when `liveUrl`, kept as it is on the app, names another database than
  * {@link ARCHON_POSTGRES_DB}: a hand-set URL on the wrong path, or a platform
- * still on the retired `archon_v2`. Names the two databases only, never the URL.
+ * still on a retired database. Names the two databases only, never the URL.
  */
 function assertArchonDatabasePath(key, liveUrl) {
     let database;

package/dist/release/run.js

@@ -1,5 +1,5 @@
 import { decide, healthRange, } from './decide.js';
-import { formatWeights, formatWindow, recordedFrom, releaseKeys, } from './state.js';
+import { formatRefusals, formatWeights, formatWindow, recordedFrom, releaseKeys, } from './state.js';
 import { isStageCopyAction } from './types.js';
 const REFUSAL_TEXT = {
     'no-copy-port': 'copy refused: this host cannot restore',
@@ -79,6 +79,10 @@ export async function runRelease(input) {
         [k.window]: formatWindow(next.window, next.release),
         [k.signal]: decision.signal ? JSON.stringify(decision.signal) : null,
     };
+    // Part of the run's writes: persisted with them, so a failed persist leaves neither. A run with none keeps it.
+    const lines = [...refused, ...decision.blocked];
+    if (lines.length > 0)
+        writes[k.refused] = formatRefusals(stamp, lines);
     for (const d of recorded.held)
         if (!next.held.includes(d))
             writes[k.held(d)] = null;
@@ -132,6 +136,7 @@ export function settleStageCopy(input) {
         writes[k.stageCopy] = `${stamp}|refused|${result.reason}`;
         writes[k.stageCopyRetry] = null;
         refused.push(REFUSAL_TEXT[result.reason] ?? `copy refused: ${result.reason}`);
+        writes[k.refused] = formatRefusals(stamp, refused);
         return { writes, refused, consume: true };
     }
     writes[k.stageCopy] = `${stamp}|failed|${result.step}`;

package/dist/release/state.d.ts

@@ -48,6 +48,8 @@ export declare function releaseKeys(entry: string): {
     stageCopyHandled: string;
     /** The id of a request whose copy failed once; a second failure consumes it. */
     stageCopyRetry: string;
+    /** JSON `{ at, lines }`: the latest run that refused or blocked something (see {@link formatRefusals}). */
+    refused: string;
 };
 export declare function formatWeights(w: Record<Color, number>): string;
 export declare function parseWeights(value: string | undefined): Record<Color, number> | null;
@@ -60,6 +62,13 @@ export declare function formatWindow(window: WindowState, release: Recorded['rel
 export declare function recordedFrom(ids: Record<string, string>, entryKey: string): Recorded | null;
 /** Reads `bg.<id>.stagecopy`; a damaged value reads as absent. */
 export declare function parseStageCopy(value: string | undefined): StageCopyState | undefined;
+/**
+ * The value of `bg.<id>.refused`: the run time and its refused lines, then its blocked lines. Capped at 20 lines
+ * of 300 characters so a bad run cannot grow the row. Callers write it only when `lines` is not empty.
+ */
+export declare function formatRefusals(at: string, lines: readonly string[]): string;
+/** Reads `bg.<id>.refused`; a damaged value reads as absent. */
+export declare function parseRefusals(value: string | undefined): ReleaseState['refused'];
 export declare function readSignal(ids: Record<string, string>, entryKey: string): ReleaseSignal | null;
 /** C2: the release state of one hosting entry, or null before blue/green recorded anything. */
 export declare function readReleaseState(store: ReleaseStore, input: {

package/dist/release/state.js

@@ -25,6 +25,8 @@ export function releaseKeys(entry) {
         stageCopyHandled: `${p}.stagecopyhandled`,
         /** The id of a request whose copy failed once; a second failure consumes it. */
         stageCopyRetry: `${p}.stagecopyretry`,
+        /** JSON `{ at, lines }`: the latest run that refused or blocked something (see {@link formatRefusals}). */
+        refused: `${p}.refused`,
     };
 }
 export function formatWeights(w) {
@@ -122,6 +124,26 @@ export function parseStageCopy(value) {
     }
     return undefined;
 }
+const REFUSED_MAX_LINES = 20;
+const REFUSED_MAX_LINE = 300;
+const refusedSchema = z.object({ at: z.string(), lines: z.array(z.string()) });
+/**
+ * The value of `bg.<id>.refused`: the run time and its refused lines, then its blocked lines. Capped at 20 lines
+ * of 300 characters so a bad run cannot grow the row. Callers write it only when `lines` is not empty.
+ */
+export function formatRefusals(at, lines) {
+    return JSON.stringify({
+        at,
+        lines: lines.slice(0, REFUSED_MAX_LINES).map((l) => l.slice(0, REFUSED_MAX_LINE)),
+    });
+}
+/** Reads `bg.<id>.refused`; a damaged value reads as absent. */
+export function parseRefusals(value) {
+    const parsed = refusedSchema.safeParse(parseJson(value));
+    if (!parsed.success || Number.isNaN(Date.parse(parsed.data.at)))
+        return undefined;
+    return parsed.data;
+}
 export function readSignal(ids, entryKey) {
     const parsed = signalSchema.safeParse(parseJson(ids[releaseKeys(entryKey).signal]));
     return parsed.success ? parsed.data : null;
@@ -133,6 +155,7 @@ export async function readReleaseState(store, input) {
     if (!r)
         return null;
     const stageCopy = parseStageCopy(ids[releaseKeys(input.entryKey).stageCopy]);
+    const refused = parseRefusals(ids[releaseKeys(input.entryKey).refused]);
     return {
         entryKey: input.entryKey,
         live: r.live,
@@ -144,6 +167,7 @@ export async function readReleaseState(store, input) {
         held: r.held,
         config: resolveReleaseConfig(input.entry),
         ...(stageCopy ? { stageCopy } : {}),
+        ...(refused ? { refused } : {}),
         ...stageDeployOf(ids[releaseKeys(input.entryKey).stageDeploy]),
     };
 }

package/dist/release/types.d.ts

@@ -59,6 +59,14 @@ export interface ReleaseState {
         outcome: 'ok' | 'failed';
         detail: string;
     };
+    /**
+     * The latest run that refused or blocked something (`bg.<id>.refused`): its time and its refused lines then its
+     * blocked lines, as decide's fixed texts (at most 20 lines of 300 characters). A run with none leaves it as is.
+     */
+    refused?: {
+        at: string;
+        lines: string[];
+    };
 }
 /** C3: what the last `copy_prod_to_stage` or `undo_stage_copy` request did. `detail` is fixed text or an id. */
 export interface StageCopyState {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtfalch/foundry",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "description": "Foundry's SDK: the declared org's types, the plan and apply contracts, and the state store's interface.",
   "repository": {
     "type": "git",