orizu 0.5.22 → 0.5.24

package/dist/child-output-tee.js

@@ -0,0 +1,512 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { closeSync, constants, mkdtempSync, openSync, read as readFileDescriptor, rmSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Readable, Writable } from 'node:stream';
+const CHILD_OUTPUT_PREFETCH_MAX_BYTES = 64 * 1024;
+const CHILD_OUTPUT_READ_BUFFER_BYTES = 16 * 1024;
+const EMPTY_FIFO_INITIAL_RETRY_MS = 4;
+const EMPTY_FIFO_MAX_RETRY_MS = 64;
+const FORWARDING_FAILURE_TERMINATION_TIMEOUT_MS = 250, LIVE_OUTPUT_STALL_TIMEOUT_MS = 1_500;
+const LIVE_OUTPUT_RELAY_SCRIPT = [
+    "const { writeSync } = require('node:fs')",
+    'process.stdout._handle?.setBlocking(true)',
+    'let buffered = Buffer.alloc(0)',
+    'process.stdin.on(\'data\', chunk => {',
+    '  buffered = Buffer.concat([buffered, chunk])',
+    '  while (buffered.length >= 4) {',
+    '    const length = buffered.readUInt32BE(0)',
+    '    if (buffered.length < length + 4) return',
+    '    const payload = buffered.subarray(4, length + 4)',
+    '    buffered = buffered.subarray(length + 4)',
+    '    for (let offset = 0; offset < payload.length; )',
+    '      offset += writeSync(1, payload, offset, payload.length - offset)',
+    "    writeSync(3, '1')",
+    '  }',
+    '})',
+    "writeSync(3, 'R')",
+].join('\n');
+class FileDescriptorSource extends Readable {
+    descriptor;
+    readBuffer = Buffer.allocUnsafe(CHILD_OUTPUT_READ_BUFFER_BYTES);
+    emptyRetryMilliseconds = EMPTY_FIFO_INITIAL_RETRY_MS;
+    isReadPending = false;
+    retryTimer;
+    pendingDestroy;
+    constructor(descriptor) {
+        super({ highWaterMark: CHILD_OUTPUT_PREFETCH_MAX_BYTES });
+        this.descriptor = descriptor;
+    }
+    _read() {
+        if (this.isReadPending || this.retryTimer || this.descriptor === undefined)
+            return;
+        this.isReadPending = true;
+        readFileDescriptor(this.descriptor, this.readBuffer, 0, this.readBuffer.byteLength, null, (error, bytesRead) => {
+            this.isReadPending = false;
+            if (this.pendingDestroy) {
+                this.finishDestroy();
+                return;
+            }
+            if (error) {
+                if (error.code === 'EINTR') {
+                    this._read();
+                    return;
+                }
+                if (['EAGAIN', 'EWOULDBLOCK'].includes(error.code ?? '')) {
+                    const delay = this.emptyRetryMilliseconds;
+                    this.emptyRetryMilliseconds = Math.min(EMPTY_FIFO_MAX_RETRY_MS, this.emptyRetryMilliseconds * 2);
+                    this.retryTimer = setTimeout(() => {
+                        this.retryTimer = undefined;
+                        this._read();
+                    }, delay);
+                    return;
+                }
+                this.destroy(error);
+                return;
+            }
+            if (bytesRead === 0) {
+                this.push(null);
+                return;
+            }
+            this.emptyRetryMilliseconds = EMPTY_FIFO_INITIAL_RETRY_MS;
+            this.push(Buffer.from(this.readBuffer.subarray(0, bytesRead)));
+        });
+    }
+    _destroy(error, callback) {
+        if (this.retryTimer)
+            clearTimeout(this.retryTimer);
+        this.retryTimer = undefined;
+        this.pendingDestroy = { error, callback };
+        if (!this.isReadPending)
+            this.finishDestroy();
+    }
+    finishDestroy() {
+        const pendingDestroy = this.pendingDestroy;
+        if (!pendingDestroy)
+            return;
+        this.pendingDestroy = undefined;
+        const descriptor = this.descriptor;
+        this.descriptor = undefined;
+        try {
+            if (descriptor !== undefined)
+                closeSync(descriptor);
+            pendingDestroy.callback(pendingDestroy.error);
+        }
+        catch (error) {
+            pendingDestroy.callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+}
+class FileDescriptorSink extends Writable {
+    descriptor;
+    activeWriteCancellations = new Set();
+    isLiveOutputAvailable = true;
+    relay;
+    constructor(descriptor) {
+        super({ highWaterMark: 16 * 1024 });
+        this.descriptor = descriptor;
+    }
+    _write(chunk, _encoding, callback) {
+        if (!this.isLiveOutputAvailable) {
+            callback();
+            return;
+        }
+        let relay;
+        let hasSettled = false;
+        const settle = (error) => {
+            if (hasSettled)
+                return;
+            hasSettled = true;
+            if (error)
+                this.isLiveOutputAvailable = false;
+            this.activeWriteCancellations.delete(cancel);
+            relay?.acknowledgements.off('data', acknowledge);
+            relay?.child.off('exit', relayExited);
+            callback(error);
+        };
+        const acknowledge = () => settle();
+        const relayExited = () => settle(new Error('live output relay exited before write acknowledgement'));
+        const cancel = () => settle();
+        this.activeWriteCancellations.add(cancel);
+        try {
+            relay = this.relayProcess();
+        }
+        catch (error) {
+            settle(errorFromUnknown(error));
+            return;
+        }
+        void relay.ready.then(() => {
+            if (hasSettled)
+                return;
+            relay.acknowledgements.once('data', acknowledge);
+            relay.child.once('exit', relayExited);
+            const frame = Buffer.allocUnsafe(chunk.byteLength + 4);
+            frame.writeUInt32BE(chunk.byteLength);
+            chunk.copy(frame, 4);
+            relay.input.write(frame, error => { if (error)
+                settle(error); });
+        }).catch(error => settle(errorFromUnknown(error)));
+    }
+    async prepare() {
+        if (!this.isLiveOutputAvailable)
+            return;
+        await this.relayProcess().ready;
+    }
+    cancelPendingWrites() {
+        this.isLiveOutputAvailable = false;
+        const relay = this.relay;
+        this.relay = undefined;
+        relay?.input.destroy();
+        relay?.child.kill('SIGKILL');
+        for (const cancel of [...this.activeWriteCancellations])
+            cancel();
+    }
+    relayProcess() {
+        if (this.relay)
+            return this.relay;
+        const child = spawn('node', ['-e', LIVE_OUTPUT_RELAY_SCRIPT], {
+            stdio: ['pipe', this.descriptor, 'ignore', 'pipe'],
+        });
+        const input = child.stdin;
+        const acknowledgements = child.stdio[3];
+        if (!input || !acknowledgements)
+            throw new Error('live output relay has no control pipes');
+        child.on('error', () => { });
+        input.on('error', () => { });
+        acknowledgements.on('error', () => { });
+        const ready = new Promise((resolve, reject) => {
+            acknowledgements.once('data', chunk => {
+                if (chunk.includes('R'.charCodeAt(0)))
+                    resolve();
+                else
+                    reject(new Error('live output relay sent an invalid readiness acknowledgement'));
+            });
+            child.once('exit', () => reject(new Error('live output relay exited before readiness')));
+            child.once('error', reject);
+        });
+        void ready.catch(() => { });
+        child.unref();
+        void ready.then(() => {
+            input.unref?.();
+            acknowledgements.unref?.();
+        }, () => { });
+        const relay = { child, input, acknowledgements, ready };
+        child.once('exit', () => {
+            if (this.relay?.child !== child)
+                return;
+            this.relay = undefined;
+        });
+        this.relay = relay;
+        return relay;
+    }
+}
+export const childOutputSinks = {
+    stdout: new FileDescriptorSink(1),
+    stderr: new FileDescriptorSink(2),
+};
+const POST_LEADER_CAPTURE_DRAIN_TIMEOUT_MS = 250;
+function closeDescriptor(descriptor) {
+    if (descriptor === undefined)
+        return;
+    try {
+        closeSync(descriptor);
+    }
+    catch {
+        // Best-effort cleanup after another operation has already failed.
+    }
+}
+function createOutputFifo(name) {
+    const root = mkdtempSync(join(tmpdir(), 'orizu-child-output-'));
+    const fifoPath = join(root, name);
+    let anchorDescriptor;
+    let readDescriptor;
+    let writeDescriptor;
+    try {
+        const creation = spawnSync('mkfifo', [fifoPath], { stdio: 'ignore' });
+        if (creation.error)
+            throw creation.error;
+        if (creation.status !== 0) {
+            throw new Error(`mkfifo exited with status ${creation.status ?? 'unknown'}`);
+        }
+        // The temporary read/write anchor prevents either open from waiting for
+        // its peer. The child inherits the blocking write end; the parent polls a
+        // nonblocking read end so descendant-held descriptors remain cancellable.
+        anchorDescriptor = openSync(fifoPath, constants.O_RDWR | constants.O_NONBLOCK);
+        readDescriptor = openSync(fifoPath, constants.O_RDONLY | constants.O_NONBLOCK);
+        writeDescriptor = openSync(fifoPath, constants.O_WRONLY);
+        closeDescriptor(anchorDescriptor);
+        anchorDescriptor = undefined;
+        const source = new FileDescriptorSource(readDescriptor);
+        readDescriptor = undefined;
+        rmSync(root, { force: true, recursive: true });
+        return { source, writeDescriptor };
+    }
+    catch (error) {
+        closeDescriptor(writeDescriptor);
+        closeDescriptor(readDescriptor);
+        closeDescriptor(anchorDescriptor);
+        rmSync(root, { force: true, recursive: true });
+        throw error;
+    }
+}
+export async function spawnPipedChild(command, args, environment) {
+    const stdout = createOutputFifo('stdout');
+    let stderr;
+    try {
+        stderr = createOutputFifo('stderr');
+    }
+    catch (error) {
+        stdout.source.destroy();
+        closeDescriptor(stdout.writeDescriptor);
+        throw error;
+    }
+    let child;
+    try {
+        // Begin the bounded parent-side drain before an immediate child crash can
+        // strand bytes in the child's userland stdout/stderr buffers.
+        stdout.source.read(0);
+        stderr.source.read(0);
+        child = spawn(command, args, {
+            env: environment,
+            stdio: ['inherit', stdout.writeDescriptor, stderr.writeDescriptor],
+        });
+    }
+    catch (error) {
+        stdout.source.destroy();
+        stderr.source.destroy();
+        throw error;
+    }
+    finally {
+        closeDescriptor(stdout.writeDescriptor);
+        closeDescriptor(stderr.writeDescriptor);
+    }
+    // `close` also waits for descendant-held stdio descriptors. Observe the
+    // leader's exit so completePipedChild can enforce its bounded EOF grace.
+    const exited = new Promise(resolve => child.once('exit', resolve));
+    try {
+        await new Promise((resolve, reject) => {
+            child.once('spawn', resolve);
+            child.once('error', reject);
+        });
+    }
+    catch (error) {
+        stdout.source.destroy();
+        stderr.source.destroy();
+        throw error;
+    }
+    return {
+        stdout: stdout.source,
+        stderr: stderr.source,
+        exited,
+        get signalCode() { return child.signalCode; },
+        kill: signal => { child.kill(signal); },
+    };
+}
+const liveSinkStates = new WeakMap();
+function liveSinkState(destination) {
+    const existing = liveSinkStates.get(destination);
+    if (existing)
+        return existing;
+    const state = { hasFailed: false };
+    destination.on('error', () => { state.hasFailed = true; });
+    liveSinkStates.set(destination, state);
+    return state;
+}
+async function writeLiveOutput(destination, state, text) {
+    if (state.hasFailed)
+        return;
+    await new Promise(resolve => {
+        try {
+            destination.write(text, error => {
+                if (error)
+                    state.hasFailed = true;
+                resolve();
+            });
+        }
+        catch {
+            state.hasFailed = true;
+            resolve();
+        }
+    });
+}
+export async function writeChildStderr(text) {
+    const sink = childOutputSinks.stderr;
+    let timer;
+    const didForward = await Promise.race([
+        writeLiveOutput(sink, liveSinkState(sink), `${text}\n`).then(() => true),
+        new Promise(resolve => {
+            timer = setTimeout(() => resolve(false), LIVE_OUTPUT_STALL_TIMEOUT_MS);
+        }),
+    ]);
+    if (timer)
+        clearTimeout(timer);
+    if (!didForward)
+        sink.cancelPendingWrites();
+}
+function errorFromUnknown(cause) {
+    return cause instanceof Error ? cause : new Error(String(cause));
+}
+async function waitForChildExit(child, timeoutMilliseconds) {
+    let timer;
+    const didExit = await Promise.race([
+        child.exited.then(() => true),
+        new Promise(resolve => {
+            timer = setTimeout(() => resolve(false), timeoutMilliseconds);
+        }),
+    ]);
+    if (timer)
+        clearTimeout(timer);
+    return didExit;
+}
+async function terminateAfterForwardingFailure(child, forwarding, captureDrain, error) {
+    child.kill('SIGTERM');
+    for (const stream of forwarding)
+        stream.stopLiveOutput();
+    child.stdout.destroy();
+    child.stderr.destroy();
+    await captureDrain;
+    if (!await waitForChildExit(child, FORWARDING_FAILURE_TERMINATION_TIMEOUT_MS)) {
+        child.kill('SIGKILL');
+        await waitForChildExit(child, FORWARDING_FAILURE_TERMINATION_TIMEOUT_MS);
+    }
+    throw error;
+}
+export async function completePipedChild(child, forwarding) {
+    const captureDrain = Promise.allSettled(forwarding.map(stream => stream.completed));
+    const firstFailure = Promise.race(forwarding.map(stream => stream.failure));
+    const firstOutcome = await Promise.race([
+        child.exited.then(status => ({ kind: 'exit', status })),
+        firstFailure.then(error => ({ kind: 'failure', error })),
+    ]);
+    if (firstOutcome.kind === 'failure') {
+        return terminateAfterForwardingFailure(child, forwarding, captureDrain, firstOutcome.error);
+    }
+    const status = firstOutcome.status;
+    const waitForCaptureDrain = async () => {
+        let timer;
+        const didDrain = await Promise.race([
+            captureDrain.then(() => true),
+            new Promise(resolve => {
+                timer = setTimeout(() => resolve(false), POST_LEADER_CAPTURE_DRAIN_TIMEOUT_MS);
+            }),
+        ]);
+        if (timer)
+            clearTimeout(timer);
+        return didDrain;
+    };
+    const throwIfCaptureFailed = async () => {
+        await captureDrain;
+        const failure = forwarding.map(stream => stream.failureReason()).find(Boolean);
+        if (failure)
+            throw failure;
+    };
+    // Preserve ordinary live forwarding when EOF is already on its way. If a
+    // blocked sink or descendant-held descriptor prevents that bounded drain,
+    // switch to capture-only before enforcing the same bounded EOF grace.
+    if (await waitForCaptureDrain()) {
+        await throwIfCaptureFailed();
+        return status;
+    }
+    for (const stream of forwarding)
+        stream.stopLiveOutput();
+    if (await waitForCaptureDrain()) {
+        await throwIfCaptureFailed();
+        return status;
+    }
+    for (const stream of forwarding)
+        stream.expectSourceClose();
+    child.stdout.destroy();
+    child.stderr.destroy();
+    await throwIfCaptureFailed();
+    return status;
+}
+export async function runPipedChild(command, args, environment, onSpawn, capture, observeChild) {
+    await Promise.all([childOutputSinks.stdout.prepare(), childOutputSinks.stderr.prepare()]);
+    const child = await spawnPipedChild(command, args, environment);
+    observeChild?.(child);
+    const forwarding = [
+        teeChildOutput(child.stdout, childOutputSinks.stdout, capture.stdout),
+        teeChildOutput(child.stderr, childOutputSinks.stderr, capture.stderr),
+    ];
+    const completion = completePipedChild(child, forwarding);
+    const firstForwardingFailure = Promise.race(forwarding.map(stream => stream.failure)).then(error => { throw error; });
+    try {
+        await Promise.race([onSpawn(), firstForwardingFailure]);
+        const exitCode = await completion;
+        return { status: child.signalCode ? null : exitCode };
+    }
+    catch (cause) {
+        child.kill('SIGTERM');
+        await completion.catch(() => undefined);
+        throw cause;
+    }
+}
+/**
+ * Forward a child stream live while retaining a bounded caller-owned copy.
+ * Transient sink slowness pushes back; a stall degrades safely to capture-only.
+ */
+export function teeChildOutput(source, destination, capture) {
+    let isLiveOutputEnabled = true;
+    let isSourceCloseExpected = false;
+    let unexpectedFailure;
+    let remainingLiveOutputWaitMilliseconds = LIVE_OUTPUT_STALL_TIMEOUT_MS;
+    let liveOutputWaitFinishedAt = performance.now();
+    let resolveLiveOutputStopped = () => { };
+    const liveOutputStopped = new Promise(resolve => { resolveLiveOutputStopped = resolve; });
+    const stopLiveOutput = () => {
+        if (!isLiveOutputEnabled)
+            return;
+        isLiveOutputEnabled = false;
+        if (destination instanceof FileDescriptorSink)
+            destination.cancelPendingWrites();
+        resolveLiveOutputStopped();
+    };
+    const sinkState = liveSinkState(destination);
+    const forward = async (text) => {
+        capture(text);
+        if (!isLiveOutputEnabled)
+            return;
+        const waitStartedAt = performance.now();
+        remainingLiveOutputWaitMilliseconds = Math.min(LIVE_OUTPUT_STALL_TIMEOUT_MS, remainingLiveOutputWaitMilliseconds + waitStartedAt - liveOutputWaitFinishedAt);
+        let stallTimer;
+        const wasForwarded = await Promise.race([
+            writeLiveOutput(destination, sinkState, text).then(() => true),
+            liveOutputStopped.then(() => false),
+            new Promise(resolve => {
+                stallTimer = setTimeout(() => resolve(false), remainingLiveOutputWaitMilliseconds);
+            }),
+        ]);
+        if (stallTimer)
+            clearTimeout(stallTimer);
+        liveOutputWaitFinishedAt = performance.now();
+        remainingLiveOutputWaitMilliseconds -= liveOutputWaitFinishedAt - waitStartedAt;
+        if (!wasForwarded || remainingLiveOutputWaitMilliseconds <= 0)
+            stopLiveOutput();
+    };
+    const completed = (async () => {
+        const decoder = new TextDecoder();
+        for await (const chunk of source) {
+            const text = decoder.decode(chunk, { stream: true });
+            if (text)
+                await forward(text);
+        }
+        const remainder = decoder.decode();
+        if (remainder)
+            await forward(remainder);
+    })();
+    let resolveFailure = () => { };
+    const failure = new Promise(resolve => { resolveFailure = resolve; });
+    void completed.catch(cause => {
+        if (isSourceCloseExpected)
+            return;
+        unexpectedFailure = errorFromUnknown(cause);
+        resolveFailure(unexpectedFailure);
+    });
+    return {
+        completed,
+        failure,
+        failureReason: () => unexpectedFailure,
+        expectSourceClose: () => { isSourceCloseExpected = true; },
+        stopLiveOutput,
+    };
+}

package/dist/cleanup.d.ts

@@ -0,0 +1,6 @@
+export type Cleanup = () => void;
+/** Attempt every disposer even when an earlier cleanup fails. */
+export declare function cleanupAll(cleanups: readonly Cleanup[], message: string): void;
+/** Preserve the operation failure together with every cleanup failure. */
+export declare function throwWithCleanup(operationError: unknown, cleanups: readonly Cleanup[], message: string): never;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../src/cleanup.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,IAAI,CAAA;AAchC,iEAAiE;AACjE,wBAAgB,UAAU,CACxB,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,OAAO,EAAE,MAAM,GACd,IAAI,CAKN;AAED,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,OAAO,EACvB,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,OAAO,EAAE,MAAM,GACd,KAAK,CAMP"}

package/dist/cleanup.js

@@ -0,0 +1,27 @@
+function collectCleanupFailures(cleanups) {
+    const failures = [];
+    for (const cleanup of cleanups) {
+        try {
+            cleanup();
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    return failures;
+}
+/** Attempt every disposer even when an earlier cleanup fails. */
+export function cleanupAll(cleanups, message) {
+    const failures = collectCleanupFailures(cleanups);
+    if (failures.length > 0) {
+        throw new AggregateError(failures, message);
+    }
+}
+/** Preserve the operation failure together with every cleanup failure. */
+export function throwWithCleanup(operationError, cleanups, message) {
+    const cleanupFailures = collectCleanupFailures(cleanups);
+    if (cleanupFailures.length > 0) {
+        throw new AggregateError([operationError, ...cleanupFailures], message);
+    }
+    throw operationError;
+}

package/dist/cli-auth-browser-page.d.ts

@@ -0,0 +1,2 @@
+export declare function renderCliAuthBrowserPage(status: 'success' | 'error'): string;
+//# sourceMappingURL=cli-auth-browser-page.d.ts.map

package/dist/cli-auth-browser-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-auth-browser-page.d.ts","sourceRoot":"","sources":["../src/cli-auth-browser-page.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,CA2G5E"}

package/dist/cli-auth-browser-page.js

@@ -0,0 +1,107 @@
+export function renderCliAuthBrowserPage(status) {
+    const isSuccess = status === 'success';
+    const eyebrow = isSuccess ? '// cli login complete' : '// cli login';
+    const title = isSuccess ? 'Browser authorization complete' : 'Missing authorization code';
+    const detail = isSuccess
+        ? 'Your terminal will finish connecting the Orizu CLI. You can close this tab.'
+        : 'Close this tab and run orizu login again to start a fresh browser request.';
+    const accent = isSuccess ? '#E8923C' : '#C8442A';
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Orizu CLI Login</title>
+    <style>
+      @import url('https://fonts.googleapis.com/css2?family=Geist+Mono:wght@400;500;700&display=swap');
+      :root {
+        color-scheme: light;
+        --paper: #F4EFE3;
+        --border: #E6DFCE;
+        --ink: #353535;
+        --muted: #6B6358;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        background: #FFFFFF;
+        color: #4B4B4B;
+        font-family: 'Geist Mono', Menlo, Monaco, Consolas, monospace;
+        letter-spacing: -0.025em;
+      }
+      main {
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 48px 24px;
+      }
+      section {
+        width: min(100%, 520px);
+        text-align: center;
+      }
+      .brand {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 12px;
+        margin-bottom: 28px;
+      }
+      .brand svg {
+        width: 42px;
+        height: 42px;
+        color: #202124;
+      }
+      .brand span {
+        color: #000000;
+        font-size: 16px;
+        font-weight: 700;
+      }
+      .eyebrow {
+        margin: 0 0 12px;
+        color: ${accent};
+        font-size: 12px;
+        text-transform: lowercase;
+      }
+      h1 {
+        margin: 0 0 8px;
+        color: var(--ink);
+        font-size: 24px;
+        line-height: 1.15;
+        letter-spacing: -0.05em;
+      }
+      .detail {
+        margin: 0;
+        color: var(--muted);
+        font-size: 13px;
+        line-height: 1.6;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <section>
+        <div class="brand" aria-hidden="true">
+          <svg viewBox="0 0 2048 2048" xmlns="http://www.w3.org/2000/svg">
+            <g fill="currentColor">
+              <polygon points="1545,879 787,1195 1189,1577"></polygon>
+              <polygon points="992,624 444,1104 688,1338"></polygon>
+              <polygon points="602,1593 1180,1594 768,1202"></polygon>
+              <polygon points="1650,1195 1398,1203 1204,1594 1229,1593"></polygon>
+              <polygon points="807,413 751,509 823,744 980,608"></polygon>
+              <polygon points="441,1127 592,1572 681,1356"></polygon>
+              <polygon points="793,399 611,457 604,471 658,602"></polygon>
+              <polygon points="593,493 498,667 636,600"></polygon>
+            </g>
+          </svg>
+          <span>orizu</span>
+        </div>
+        <p class="eyebrow">${eyebrow}</p>
+        <h1>${title}</h1>
+        <p class="detail">${detail}</p>
+      </section>
+    </main>
+  </body>
+</html>`;
+}