@storystick/preview 0.0.0-stage → 0.2.0-rc.1

package/dist/server/route-session-cookie.d.ts

@@ -0,0 +1,33 @@
+import { type PreviewGrantActivationResponse, type PreviewGrantCookie } from './grant.js';
+import { type AdmissionScope, type PreviewAdmission, type PreviewCookieReader } from './admission-cookie.js';
+type CookieWritableResponse = {
+    cookies: {
+        set: (name: string, value: string, options: {
+            httpOnly?: boolean;
+            secure?: boolean;
+            sameSite?: 'none' | 'lax' | 'strict' | boolean;
+            partitioned?: boolean;
+            path?: string;
+            maxAge?: number;
+        }) => void;
+    };
+};
+export declare function buildPreviewGrantCookieFromActivation(activation: PreviewGrantActivationResponse, now?: number, applicationBuildId?: string): PreviewGrantCookie;
+type CookieWriteOptions = {
+    response: CookieWritableResponse;
+    scope: AdmissionScope;
+    reader: PreviewCookieReader;
+    requestUrl: string;
+    basePath: string;
+    now?: number;
+};
+/** Deletes only exact names observed by this request, never a shared current slot. */
+export declare function prunePreviewAdmissionCookies(args: CookieWriteOptions, sequence: number): void;
+export declare function setPreviewGrantCookieOnResponse(args: CookieWriteOptions & {
+    cookie: PreviewGrantCookie;
+    sequence: number;
+}): Promise<void>;
+export declare function closePreviewAdmissionOnResponse(args: CookieWriteOptions & {
+    admission: PreviewAdmission;
+}): Promise<void>;
+export {};

package/dist/server/route-session-cookie.js

@@ -0,0 +1,54 @@
+import { previewPresenceCookieName } from '@storystick/preview/identity/preview-cookie';
+import { previewCookieAttributes, previewCapabilityCookieName } from './grant.js';
+import { admissionCookieName, admissionPresenceName, encodePreviewAdmission, invalidAdmissionNames, PREVIEW_CLOSURE_TTL_MS } from './admission-cookie.js';
+export function buildPreviewGrantCookieFromActivation(activation, now = Date.now(), applicationBuildId) {
+    return { v: 2, grantId: activation.grantId, grantToken: activation.grantToken,
+        grantExpiresAt: activation.grantExpiresAt, projectId: activation.projectId, previewOrigin: activation.previewOrigin,
+        accessToken: activation.token, accessExpiresAt: now + activation.tokenExpiresIn * 1000,
+        contentShapeCapability: activation.contentShapeCapability, ...(applicationBuildId ? { applicationBuildId } : {}) };
+}
+async function writeAdmission(args, admission) {
+    const attrs = previewCookieAttributes({ expiresIn: Math.ceil((admission.expiresAt - (args.now ?? Date.now())) / 1000),
+        requestUrl: args.requestUrl, basePath: args.basePath });
+    args.response.cookies.set(await admissionCookieName(args.scope, admission), await encodePreviewAdmission(admission, args.scope), attrs);
+    args.response.cookies.set(await admissionPresenceName(args.scope, admission), '1', { ...attrs, httpOnly: false });
+    prunePreviewAdmissionCookies(args, admission.sequence);
+}
+/** Deletes only exact names observed by this request, never a shared current slot. */
+export function prunePreviewAdmissionCookies(args, sequence) {
+    const prefixes = [previewCapabilityCookieName(args.scope), previewPresenceCookieName(args.scope)];
+    const attrs = previewCookieAttributes({ expiresIn: 0, requestUrl: args.requestUrl, basePath: args.basePath });
+    for (const { name } of args.reader.getAll()) {
+        for (const prefix of prefixes) {
+            const suffix = name.startsWith(prefix + '_') ? name.slice(prefix.length) : '';
+            const match = /^_[ax]([1-9]\d*)_[A-Za-z0-9_-]{22}$/.exec(suffix);
+            // Retired fixed cookies cannot override admissions, and may be removed.
+            if (name === prefix || (match && Number(match[1]) < sequence)) {
+                args.response.cookies.set(name, '', { ...attrs, httpOnly: prefix === prefixes[0] });
+            }
+        }
+    }
+}
+export async function setPreviewGrantCookieOnResponse(args) {
+    const attrs = previewCookieAttributes({ expiresIn: 0, requestUrl: args.requestUrl, basePath: args.basePath });
+    for (const name of await invalidAdmissionNames(args.reader, args.scope)) {
+        args.response.cookies.set(name, '', attrs);
+        args.response.cookies.set(name.replace(previewCapabilityCookieName(args.scope), previewPresenceCookieName(args.scope)), '', { ...attrs, httpOnly: false });
+    }
+    await writeAdmission(args, { kind: 'active', sequence: args.sequence, expiresAt: args.cookie.grantExpiresAt, grant: args.cookie });
+}
+export async function closePreviewAdmissionOnResponse(args) {
+    // A late activation response for this same grant cannot overwrite its closure:
+    // active and closed have different names, and closed wins at equal sequence.
+    await writeAdmission(args, { kind: 'closed', sequence: args.admission.sequence,
+        expiresAt: Math.max(args.admission.expiresAt, (args.now ?? Date.now()) + PREVIEW_CLOSURE_TTL_MS) });
+    // Keep the small closure, not its credentials. A delayed same-rank active
+    // response remains suppressed by the distinct closure name.
+    const active = { kind: 'active', sequence: args.admission.sequence };
+    const names = [await admissionCookieName(args.scope, active), await admissionPresenceName(args.scope, active)];
+    const attrs = previewCookieAttributes({ expiresIn: 0, requestUrl: args.requestUrl, basePath: args.basePath });
+    for (const { name } of args.reader.getAll())
+        if (names.includes(name)) {
+            args.response.cookies.set(name, '', { ...attrs, httpOnly: name === names[0] });
+        }
+}

package/dist/session-projections.d.ts

@@ -0,0 +1,33 @@
+import type { PreviewSessionData } from './session-subscriber.js';
+import { type PreviewContentRefreshDecision } from './provenance/index.js';
+export interface PreviewSessionRoutingState {
+    sessionId: string;
+    previewedDocumentId: string;
+    pathname: string;
+    activeVariantId: string | null;
+    activeReleaseId: string | null;
+    parentOrigin: string;
+}
+export interface PreviewSessionDraftState {
+    draftDocumentId: string | null;
+    draftTarget: PreviewSessionData['draftTarget'];
+}
+export interface PreviewSessionRevisionState {
+    contentRevision: number;
+    contentRefreshDecision: PreviewContentRefreshDecision;
+}
+export interface PreviewSessionIdentityState {
+    sessionId: string;
+    parentOrigin: string;
+}
+export interface PreviewSessionProjections {
+    identity: PreviewSessionIdentityState;
+    routing: PreviewSessionRoutingState;
+    draft: PreviewSessionDraftState;
+    revision: PreviewSessionRevisionState;
+}
+export declare function projectPreviewSessionIdentity(session: PreviewSessionData): PreviewSessionIdentityState;
+export declare function projectPreviewSessionRouting(session: PreviewSessionData): PreviewSessionRoutingState;
+export declare function projectPreviewSessionDraft(session: PreviewSessionData): PreviewSessionDraftState;
+export declare function projectPreviewSessionRevision(session: PreviewSessionData): PreviewSessionRevisionState;
+export declare function projectPreviewSession(session: PreviewSessionData): PreviewSessionProjections;

package/dist/session-projections.js

@@ -0,0 +1,43 @@
+import { createPreviewContentRefreshDecision, isPreviewContentRefreshDecision, } from './provenance/index.js';
+export function projectPreviewSessionIdentity(session) {
+    return {
+        sessionId: session.sessionId,
+        parentOrigin: session.parentOrigin,
+    };
+}
+export function projectPreviewSessionRouting(session) {
+    return {
+        sessionId: session.sessionId,
+        previewedDocumentId: session.previewedDocumentId,
+        pathname: session.pathname,
+        activeVariantId: session.activeVariantId,
+        activeReleaseId: session.activeReleaseId ?? null,
+        parentOrigin: session.parentOrigin,
+    };
+}
+export function projectPreviewSessionDraft(session) {
+    return {
+        draftDocumentId: session.draftDocumentId,
+        draftTarget: session.draftTarget ?? null,
+    };
+}
+export function projectPreviewSessionRevision(session) {
+    return {
+        contentRevision: session.contentRevision,
+        contentRefreshDecision: isPreviewContentRefreshDecision(session.contentRefreshDecision)
+            ? session.contentRefreshDecision
+            : createPreviewContentRefreshDecision({
+                refresh: true,
+                affectedFrameIds: [],
+                reason: 'legacy-refresh',
+            }),
+    };
+}
+export function projectPreviewSession(session) {
+    return {
+        identity: projectPreviewSessionIdentity(session),
+        routing: projectPreviewSessionRouting(session),
+        draft: projectPreviewSessionDraft(session),
+        revision: projectPreviewSessionRevision(session),
+    };
+}

package/dist/session-subscriber.d.ts

@@ -0,0 +1,124 @@
+/**
+ * `getPreviewSession` Convex sub wrapper (ADR-087 §3.4).
+ *
+ * Once the iframe has acquired a PreviewGrant-backed access JWT and created
+ * its Convex client, the SDK subscribes to
+ * `sdkQueries:getPreviewSession({ sessionId })` to learn the live
+ * preview-routing state : which document is currently being edited
+ * (`previewedDocumentId`), the active variant (`activeVariantId`),
+ * the pathname Studio wants the iframe to be on (`pathname`), and
+ * the parent origin recorded server-side as defense-in-depth
+ * (`parentOrigin`, CSO-PREVIEW-4).
+ *
+ * PreviewGrant/context failures are terminal. Unstructured failures (network,
+ * relay restarts, access-token rollover) map to `UNKNOWN` so the coordinator
+ * can reconnect while preserving the last rendered frame.
+ *
+ * The wrapper accepts an opaque `subscribe` callable so tests don't
+ * need a real `ConvexReactClient`. In production the callable wraps
+ * the documented `client.watchQuery(query, args).onUpdate(callback)`
+ * pattern from `convex/react` — the callback receives no args, and
+ * the wrapper pulls the current value via `localQueryResult()` (a
+ * thrown ConvexError there propagates as an `onError` call).
+ */
+import type { PreviewContentRefreshDecision } from './provenance/index.js';
+import type { PreviewQueryTargetingSignalV1 } from '@storystick/types/preview-query-targeting';
+/** Shape of the session row returned by `getPreviewSession`. */
+export interface PreviewSessionData {
+    sessionId: string;
+    readContext: import('@storystick/types/preview-query-targeting').PreviewReadContext;
+    readContextStatus: 'active' | 'ended';
+    readContextNotice?: 'release-published' | 'release-archived' | null;
+    previewedDocumentId: string;
+    pathname: string;
+    activeVariantId: string | null;
+    activeReleaseId: string | null;
+    parentOrigin: string;
+    /** Frozen, validated Studio opening destination; not the currently browsed page. */
+    standaloneStudioUrl?: string | null;
+    /**
+     * ADR-096: monotonic counter bumped from Studio's autosave path on
+     * each successful document write. The Next adapter's
+     * `<StorystickPreview>` observes this field via the Provider's context
+     * and fires `router.refresh()` on forward jumps. Defaults to 0 for
+     * legacy rows (pre-ADR-096) so the SDK contract is total.
+     */
+    contentRevision: number;
+    contentRefreshDecision?: PreviewContentRefreshDecision;
+    /**
+     * ADR-099 D11: Cas A draft signal. `null` when not in Cas A — the
+     * customer's layout falls through to its normal route. `string` when
+     * Cas A is active — `resolvePreviewDraft()` (`@storystick/next/server`)
+     * fetches the doc by id and the layout substitutes children with the
+     * customer's `<Renderer>`. Total contract (`string | null`, never
+     * `undefined`).
+     */
+    draftDocumentId: string | null;
+    draftTarget?: {
+        kind: 'document';
+        id: string;
+    } | {
+        kind: 'template';
+        id: string;
+    } | null;
+}
+export interface PreviewContentSignalData {
+    sessionId: string;
+    contentRevision: number;
+    contentRefreshDecision?: PreviewContentRefreshDecision;
+    /** Content Plane source sequence this invalidation must observe. */
+    requiredProjectedThroughSeq?: number;
+    queryTargeting?: PreviewQueryTargetingSignalV1;
+}
+/** Error codes the wrapper maps from `ConvexError.data.code`. */
+export type PreviewSessionErrorCode = 'PREVIEW_REQUIRED' | 'PREVIEW_GRANT_REQUIRED' | 'PREVIEW_GRANT_INVALID' | 'PREVIEW_GRANT_REVOKED' | 'PREVIEW_ACCESS_REVOKED' | 'PREVIEW_GRANT_EXPIRED' | 'PREVIEW_GRANT_FORBIDDEN' | 'PREVIEW_CONTEXT_INVALID' | 'PREVIEW_VIEW_UNAVAILABLE' | 'PREVIEW_ADMISSION_SUPERSEDED' | 'INVALID_IDENTITY_CLAIM' | 'UNKNOWN';
+export type TerminalPreviewSessionErrorCode = Exclude<PreviewSessionErrorCode, 'UNKNOWN' | 'PREVIEW_ADMISSION_SUPERSEDED'>;
+export declare function isTerminalPreviewSessionErrorCode(code: PreviewSessionErrorCode): code is TerminalPreviewSessionErrorCode;
+/**
+ * Minimal subscribe callable shape (matches what `ConvexReactClient`
+ * exposes). The caller owns the full client ; this module is just
+ * the thin layer that maps Convex errors to our internal error
+ * codes.
+ */
+export type SubscribeCallable<TArgs, TResult> = (args: TArgs, onUpdate: (value: TResult) => void, onError?: (err: unknown) => void) => () => void;
+export interface SubscribeOptions {
+    sessionId: string;
+    mode?: 'routing-only';
+    /** Called on every successful update. */
+    onUpdate: (data: PreviewSessionData) => void;
+    /** Called on a typed Convex error mapped to our code. */
+    onError: (code: PreviewSessionErrorCode, message: string) => void;
+    /**
+     * The Convex subscribe callable. Bound to the
+     * `sdkQueries:getPreviewSession` UDF by the caller.
+     */
+    subscribe: SubscribeCallable<{
+        sessionId: string;
+        mode?: 'routing-only';
+    }, PreviewSessionData>;
+}
+export interface SubscribeContentSignalOptions {
+    sessionId: string;
+    onUpdate: (data: PreviewContentSignalData) => void;
+    onError: (code: PreviewSessionErrorCode, message: string) => void;
+    subscribe: SubscribeCallable<{
+        sessionId: string;
+    }, PreviewContentSignalData>;
+}
+/**
+ * Map an unknown thrown value to one of our typed codes. ConvexError
+ * carries a `data` payload that survives the wire ; we look for a
+ * `code` field with the PreviewGrant boundary values, falling back to
+ * `UNKNOWN` for transport/runtime failures.
+ */
+export declare function mapPreviewSessionError(err: unknown): {
+    code: PreviewSessionErrorCode;
+    message: string;
+};
+/**
+ * Subscribe to the live `getPreviewSession` row. Returns an
+ * unsubscribe function. The unsubscribe is synchronous and idempotent
+ * (calling it twice is a no-op).
+ */
+export declare function subscribePreviewSession(opts: SubscribeOptions): () => void;
+export declare function subscribePreviewContentSignal(opts: SubscribeContentSignalOptions): () => void;

package/dist/session-subscriber.js

@@ -0,0 +1,79 @@
+import { isPreviewReadContext } from '@storystick/types/preview-query-targeting';
+export function isTerminalPreviewSessionErrorCode(code) {
+    return code !== 'UNKNOWN' && code !== 'PREVIEW_ADMISSION_SUPERSEDED';
+}
+/**
+ * Map an unknown thrown value to one of our typed codes. ConvexError
+ * carries a `data` payload that survives the wire ; we look for a
+ * `code` field with the PreviewGrant boundary values, falling back to
+ * `UNKNOWN` for transport/runtime failures.
+ */
+export function mapPreviewSessionError(err) {
+    if (err && typeof err === 'object') {
+        const e = err;
+        const code = e.data?.code;
+        if (code === 'PREVIEW_REQUIRED' ||
+            code === 'PREVIEW_GRANT_REQUIRED' ||
+            code === 'PREVIEW_GRANT_INVALID' ||
+            code === 'PREVIEW_GRANT_REVOKED' ||
+            code === 'PREVIEW_ACCESS_REVOKED' ||
+            code === 'PREVIEW_GRANT_EXPIRED' ||
+            code === 'PREVIEW_GRANT_FORBIDDEN' ||
+            code === 'PREVIEW_CONTEXT_INVALID' ||
+            code === 'PREVIEW_VIEW_UNAVAILABLE' ||
+            code === 'PREVIEW_ADMISSION_SUPERSEDED' ||
+            code === 'INVALID_IDENTITY_CLAIM') {
+            return {
+                code,
+                message: typeof e.message === 'string' ? e.message : code,
+            };
+        }
+        if (typeof e.message === 'string') {
+            return { code: 'UNKNOWN', message: e.message };
+        }
+    }
+    return { code: 'UNKNOWN', message: String(err) };
+}
+/**
+ * Subscribe to the live `getPreviewSession` row. Returns an
+ * unsubscribe function. The unsubscribe is synchronous and idempotent
+ * (calling it twice is a no-op).
+ */
+export function subscribePreviewSession(opts) {
+    const unsubscribe = opts.subscribe({
+        sessionId: opts.sessionId,
+        ...(opts.mode ? { mode: opts.mode } : {}),
+    }, (value) => {
+        if (!value || !isPreviewReadContext(value.readContext) ||
+            (value.readContextStatus !== 'active' && value.readContextStatus !== 'ended')) {
+            opts.onError('PREVIEW_CONTEXT_INVALID', 'Preview returned an invalid read context.');
+            return;
+        }
+        opts.onUpdate(value);
+    }, (err) => {
+        const { code, message } = mapPreviewSessionError(err);
+        opts.onError(code, message);
+    });
+    let stopped = false;
+    return () => {
+        if (stopped)
+            return;
+        stopped = true;
+        unsubscribe();
+    };
+}
+export function subscribePreviewContentSignal(opts) {
+    const unsubscribe = opts.subscribe({ sessionId: opts.sessionId }, (value) => {
+        opts.onUpdate(value);
+    }, (err) => {
+        const { code, message } = mapPreviewSessionError(err);
+        opts.onError(code, message);
+    });
+    let stopped = false;
+    return () => {
+        if (stopped)
+            return;
+        stopped = true;
+        unsubscribe();
+    };
+}

package/dist/sha256-fallback.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Pure-JS SHA-256 fallback for `computeRouteHash`.
+ *
+ * Web Crypto requires a SECURE CONTEXT, and a cross-origin iframe
+ * inherits its embedder chain's secure-context state. In dev:
+ *
+ *   - Studio runs on `http://storystick.dojo:3000` — `.dojo` is not
+ *     `localhost`, so this origin is NOT a potentially-trustworthy
+ *     URL, so the embedder chain is not secure.
+ *   - The iframe at `http://localhost:5176` would be a secure context
+ *     on its own, but per W3C Secure Contexts §4.3 the embedder chain
+ *     must also be secure → the iframe inherits non-secure →
+ *     `crypto.subtle` is `undefined`.
+ *
+ * In production the chain is HTTPS↔HTTPS so Web Crypto is available
+ * and this fallback never runs.
+ *
+ * Correctness invariant : output MUST byte-for-byte match Web Crypto's
+ * `SHA-256` hex output for the same input. Verified by unit test —
+ * `tests/sha256-fallback.test.ts` cross-checks against Node's
+ * webcrypto for the same string inputs.
+ *
+ * Implementation : direct transcription of FIPS PUB 180-4 §6.2 SHA-256.
+ * The constants `K` are §4.2.2 ; the message schedule + compression
+ * loop is §6.2.2. Operating on big-endian 32-bit words.
+ */
+/**
+ * Compute SHA-256 of a UTF-8 string. Returns lowercase hex.
+ */
+export declare function sha256HexFallback(input: string): string;

package/dist/sha256-fallback.js

@@ -0,0 +1,126 @@
+/**
+ * Pure-JS SHA-256 fallback for `computeRouteHash`.
+ *
+ * Web Crypto requires a SECURE CONTEXT, and a cross-origin iframe
+ * inherits its embedder chain's secure-context state. In dev:
+ *
+ *   - Studio runs on `http://storystick.dojo:3000` — `.dojo` is not
+ *     `localhost`, so this origin is NOT a potentially-trustworthy
+ *     URL, so the embedder chain is not secure.
+ *   - The iframe at `http://localhost:5176` would be a secure context
+ *     on its own, but per W3C Secure Contexts §4.3 the embedder chain
+ *     must also be secure → the iframe inherits non-secure →
+ *     `crypto.subtle` is `undefined`.
+ *
+ * In production the chain is HTTPS↔HTTPS so Web Crypto is available
+ * and this fallback never runs.
+ *
+ * Correctness invariant : output MUST byte-for-byte match Web Crypto's
+ * `SHA-256` hex output for the same input. Verified by unit test —
+ * `tests/sha256-fallback.test.ts` cross-checks against Node's
+ * webcrypto for the same string inputs.
+ *
+ * Implementation : direct transcription of FIPS PUB 180-4 §6.2 SHA-256.
+ * The constants `K` are §4.2.2 ; the message schedule + compression
+ * loop is §6.2.2. Operating on big-endian 32-bit words.
+ */
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+function rotr(x, n) {
+    return ((x >>> n) | (x << (32 - n))) >>> 0;
+}
+function toHex(bytes) {
+    let out = '';
+    for (let i = 0; i < bytes.length; i++) {
+        out += bytes[i].toString(16).padStart(2, '0');
+    }
+    return out;
+}
+/**
+ * Compute SHA-256 of a UTF-8 string. Returns lowercase hex.
+ */
+export function sha256HexFallback(input) {
+    const utf8 = new TextEncoder().encode(input);
+    return sha256BytesHex(utf8);
+}
+function sha256BytesHex(bytes) {
+    // ── Pad message per §5.1.1 ──────────────────────────────────────
+    const L = bytes.length;
+    // Append 0x80 + 0x00s + 64-bit big-endian length-in-bits.
+    const totalLen = ((L + 9 + 63) >>> 6) << 6;
+    const padded = new Uint8Array(totalLen);
+    padded.set(bytes);
+    padded[L] = 0x80;
+    const bitLenHi = Math.floor(L / 0x20000000); // (L * 8) / 2^32
+    const bitLenLo = (L * 8) >>> 0;
+    const view = new DataView(padded.buffer);
+    view.setUint32(totalLen - 8, bitLenHi);
+    view.setUint32(totalLen - 4, bitLenLo);
+    // ── Initial hash values §5.3.3 ──────────────────────────────────
+    const H = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c,
+        0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const W = new Uint32Array(64);
+    for (let block = 0; block < totalLen; block += 64) {
+        // ── Prepare message schedule §6.2.2 step 1 ────────────────────
+        for (let t = 0; t < 16; t++) {
+            W[t] = view.getUint32(block + t * 4);
+        }
+        for (let t = 16; t < 64; t++) {
+            const wt15 = W[t - 15];
+            const wt2 = W[t - 2];
+            const s0 = rotr(wt15, 7) ^ rotr(wt15, 18) ^ (wt15 >>> 3);
+            const s1 = rotr(wt2, 17) ^ rotr(wt2, 19) ^ (wt2 >>> 10);
+            W[t] = (W[t - 16] + s0 + W[t - 7] + s1) >>> 0;
+        }
+        // ── Init working vars §6.2.2 step 2 ──────────────────────────
+        let a = H[0], b = H[1], c = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+        // ── Main loop §6.2.2 step 3 ──────────────────────────────────
+        for (let t = 0; t < 64; t++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const T1 = (h + S1 + ch + K[t] + W[t]) >>> 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const mj = (a & b) ^ (a & c) ^ (b & c);
+            const T2 = (S0 + mj) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + T1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (T1 + T2) >>> 0;
+        }
+        // ── §6.2.2 step 4 ────────────────────────────────────────────
+        H[0] = (H[0] + a) >>> 0;
+        H[1] = (H[1] + b) >>> 0;
+        H[2] = (H[2] + c) >>> 0;
+        H[3] = (H[3] + d) >>> 0;
+        H[4] = (H[4] + e) >>> 0;
+        H[5] = (H[5] + f) >>> 0;
+        H[6] = (H[6] + g) >>> 0;
+        H[7] = (H[7] + h) >>> 0;
+    }
+    // ── Output as big-endian bytes → hex ────────────────────────────
+    const out = new Uint8Array(32);
+    for (let i = 0; i < 8; i++) {
+        out[i * 4 + 0] = (H[i] >>> 24) & 0xff;
+        out[i * 4 + 1] = (H[i] >>> 16) & 0xff;
+        out[i * 4 + 2] = (H[i] >>> 8) & 0xff;
+        out[i * 4 + 3] = H[i] & 0xff;
+    }
+    return toHex(out);
+}