blogwright 0.4.0-beta.4 → 0.4.0-beta.5

package/dist/render.d.ts

@@ -45,10 +45,22 @@ export interface HistoryEntry {
     status: 'succeeded' | 'failed';
     finishedAt: string;
     durationMs: number;
+    /** The Web Function revision recorded for the hash (SSR mode only). */
+    webFunction?: {
+        revisionId: string;
+    } | undefined;
 }
+/**
+ * Printed in the revision column for a hash with no recorded revision - never
+ * a blank cell, so plain output stays whitespace-separated column-per-field.
+ */
+export declare const NO_REVISION = "-";
+/** Whether `history` shows the revision column: once any hash recorded one. */
+export declare function historyHasRevisions(entries: readonly HistoryEntry[]): boolean;
 /**
  * The pretty deployment table for `history`: relative times, a live marker on
- * the newest success. Entries arrive newest-first (the caller sorts).
+ * the newest success, and - in SSR mode - the revision each hash recorded.
+ * Entries arrive newest-first (the caller sorts).
  */
 export declare function renderHistoryTable(entries: HistoryEntry[], now: number): string[];
 /** One installed plugin's row in `blogwright plugin list`. */

package/dist/render.js

@@ -85,11 +85,22 @@ export function logStatusEntries(entries, pretty, logger) {
         logger.info(`  ${mark}  ${entry.title} ${entry.detail ? colors.dim(entry.detail) : ''}`);
     }
 }
+/**
+ * Printed in the revision column for a hash with no recorded revision - never
+ * a blank cell, so plain output stays whitespace-separated column-per-field.
+ */
+export const NO_REVISION = '-';
+/** Whether `history` shows the revision column: once any hash recorded one. */
+export function historyHasRevisions(entries) {
+    return entries.some((e) => e.webFunction);
+}
 /**
  * The pretty deployment table for `history`: relative times, a live marker on
- * the newest success. Entries arrive newest-first (the caller sorts).
+ * the newest success, and - in SSR mode - the revision each hash recorded.
+ * Entries arrive newest-first (the caller sorts).
  */
 export function renderHistoryTable(entries, now) {
+    const revisions = historyHasRevisions(entries);
     const liveIndex = entries.findIndex((e) => e.status === 'succeeded');
     const rows = entries.map((e, i) => {
         const mark = e.status === 'succeeded' ? colors.green('✓') : colors.red('✗');
@@ -97,11 +108,13 @@ export function renderHistoryTable(entries, now) {
             e.hash.padEnd(13),
             mark,
             formatAgo(now - Date.parse(e.finishedAt)).padEnd(9),
-            formatDuration(e.durationMs).padEnd(7),
+            formatDuration(e.durationMs).padEnd(revisions ? 8 : 7),
+            ...(revisions ? [e.webFunction?.revisionId ?? NO_REVISION] : []),
         ].join(' ');
         return i === liveIndex ? `${cells} ${colors.cyan('← live')}` : cells;
     });
-    return [colors.bold(`${'hash'.padEnd(13)} ${' '} ${'finished'.padEnd(9)} duration`), ...rows];
+    const header = `${'hash'.padEnd(13)} ${' '} ${'finished'.padEnd(9)} duration${revisions ? ' revision' : ''}`;
+    return [colors.bold(header), ...rows];
 }
 /**
  * Printed in place of a cell the plugin genuinely has no value for. An

package/dist/web-functions.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The SSR deploy contract: build-result reading, revision fingerprints, the
+ * signed endpoint probes, publishing a revision, the restore path when a
+ * revision is Active but never serves, and rollback from a recorded artifact.
+ *
+ * `commands.ts` orchestrates; this module owns the sequence. Every cloud call
+ * goes through `ctx.clients`, so the whole contract is covered by transport
+ * mocks - `floci` does not emulate `lambda-web`.
+ */
+import { type RawResponse, type SsrConfig } from 'blogwright-core';
+import type { OpsContext } from './context.js';
+import { type DeployManifest, type InvalidationSummary } from './deploy.js';
+/** The environment's `ssr` block, or a refusal naming what is missing. */
+export declare function requireSsr(ctx: OpsContext): SsrConfig;
+/** What the build agent wrote to `web/results/<hash>.json`. */
+export interface WebFunctionBuildResult {
+    artifactKey: string;
+    artifactVersionId: string;
+    artifactSha256: string;
+    artifactSize: number;
+    staleStaticKeys: string[];
+}
+/** The revision-scoped settings, exactly as they are sent to the service. */
+export interface RevisionSettings {
+    entryPoint: string;
+    env: Record<string, string>;
+    timeoutSeconds: number;
+    maxConcurrencyPerEnvironment: number;
+}
+/** The tag the fingerprint is stored under in a revision's `description`. */
+export declare const FINGERPRINT_PREFIX = "blogwright:";
+/**
+ * The revision-scoped settings as sent: the resolved environment carries
+ * `NODE_ENV=production` unless `ssr.env` overrides it, and
+ * `AWS_LAMBDA_NODEJS_ENTRYPOINT` whenever the entry point is not the runtime's
+ * `index.js` default. With `ssr.shim` set, the entry point is the generated
+ * shim, which starts `ssr.entryPoint` itself.
+ */
+export declare function revisionSettings(ctx: OpsContext): RevisionSettings;
+/**
+ * The revision fingerprint: a sha256 over the artifact digest, the runtime,
+ * the execution role, the log group and the revision-scoped settings as they
+ * will be sent. Two deploys with the same fingerprint produce the same
+ * revision, so the second creates nothing.
+ */
+export declare function revisionFingerprint(ctx: OpsContext, artifactSha256: string): string;
+/**
+ * True for the one signal that distinguishes an authorization refusal from an
+ * application answer: Lambda omits `lambda-web-error-type` when the caller may
+ * not invoke the endpoint at all.
+ */
+export declare function isInvokeAuthorizationFailure(response: RawResponse): boolean;
+/**
+ * The mandatory preflight, run BEFORE anything is built or published. Any
+ * answer from the application passes, including the placeholder's 503; only a
+ * caller that cannot invoke the endpoint at all stops here.
+ */
+export declare function preflightWebFunction(ctx: OpsContext): Promise<void>;
+/** Read the agent's result sidecar for a hash. */
+export declare function readWebBuildResult(ctx: OpsContext, hash: string): Promise<WebFunctionBuildResult>;
+/**
+ * Wait for the endpoint to answer below 500; anything else retries. The
+ * pacing is a parameter so tests can pin a retry boundary without waiting out
+ * the production window.
+ */
+export interface ProbePacing {
+    intervalMs?: number | undefined;
+    timeoutMs?: number | undefined;
+}
+/** The manifest's `webFunction` block, written only for a serving revision. */
+export interface WebFunctionManifest {
+    revisionId: string;
+    revisionArn: string;
+    fingerprint: string;
+    artifactKey: string;
+    artifactVersionId: string;
+    artifactSha256: string;
+    settings: RevisionSettings;
+    endpointName: string;
+    endpointDomainName: string;
+}
+/** Timing/identity a manifest needs, independent of whether a build ran. */
+export interface ManifestSource {
+    hash: string;
+    sourceKey: string;
+    startedAt: Date;
+    microvmId: string;
+}
+/**
+ * Record an outcome. The manifest is written only when the outcome is known,
+ * and a failed one keeps the hash's last verified `webFunction` block.
+ */
+export declare function recordManifest(ctx: OpsContext, source: ManifestSource, status: 'succeeded' | 'failed', webFunction?: WebFunctionManifest, message?: string): Promise<DeployManifest>;
+export interface PublishOutcome {
+    manifest: DeployManifest;
+    /** False when the fingerprint already served and no revision was created. */
+    created: boolean;
+    revisionId: string;
+    invalidation: InvalidationSummary;
+    staleKeysDeleted: number;
+}
+/**
+ * Publish a revision for a finished build: compare fingerprints, capture what
+ * is serving, create and verify, restore on a failed readiness probe, and only
+ * then touch the cache and the stale site keys.
+ */
+export declare function publishWebRevision(ctx: OpsContext, source: ManifestSource, result: WebFunctionBuildResult, pacing?: ProbePacing): Promise<PublishOutcome>;
+/**
+ * Rollback's artifact path: reproduce a recorded revision from the artifact
+ * version and settings in that hash's manifest, without a rebuild. Skips
+ * creation when the recorded fingerprint is already what serves, and probes
+ * and invalidates exactly as a deploy does.
+ */
+export declare function publishRecordedRevision(ctx: OpsContext, source: ManifestSource, recorded: WebFunctionManifest, pacing?: ProbePacing): Promise<PublishOutcome>;
+/**
+ * `seo` is inert in SSR mode - the application owns robots.txt and
+ * sitemap.xml - so a written, non-`off` value warns once per deploy. The check
+ * reads the RAW config document: the merged defaults are `auto`, so reading
+ * the merged config would warn on every SSR deploy.
+ */
+export declare function warnAboutSsrSeo(ctx: OpsContext): void;
+/** Refuse a preview command on an environment that configures SSR. */
+export declare function assertNotSsrForPreviews(ctx: OpsContext): void;