@oscharko-dev/keiko 0.1.0-beta.0

package/dist/ui/runs.d.ts

@@ -0,0 +1,43 @@
+import type { QueueEventSink } from "./sink.js";
+export type RunStatus = "running" | "completed" | "cancelled" | "failed";
+export interface AppliableSnapshot {
+    readonly kind: "unit-tests" | "bug-investigation";
+    readonly payload: unknown;
+    readonly limits: Record<string, unknown> | undefined;
+}
+export interface RunRecord {
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly modelId: string;
+    readonly sink: QueueEventSink;
+    status: RunStatus;
+    report: unknown;
+    readonly cancel: (reason?: string) => void;
+    appliable: AppliableSnapshot | undefined;
+    applyReport: unknown;
+    appliedAt: number | undefined;
+    terminatedAt: number | undefined;
+}
+export interface RegisterRunInput {
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly modelId: string;
+    readonly sink: QueueEventSink;
+    readonly cancel: (reason?: string) => void;
+}
+export interface RunRegistryOptions {
+    readonly maxActiveRuns?: number | undefined;
+    readonly terminatedTtlMs?: number | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export declare class ActiveRunLimitError extends Error {
+    constructor(limit: number);
+}
+export interface RunRegistry {
+    register: (input: RegisterRunInput) => RunRecord;
+    get: (runId: string) => RunRecord | undefined;
+    complete: (runId: string, status: Exclude<RunStatus, "running">, report: unknown, appliable: AppliableSnapshot | undefined) => void;
+    activeCount: () => number;
+    size: () => number;
+}
+export declare function createRunRegistry(options?: RunRegistryOptions): RunRegistry;

package/dist/ui/runs.js

@@ -0,0 +1,92 @@
+// The in-memory run registry (ADR-0011 D7). It maps a runId to a live run record (the streaming
+// sink, the run status, the captured final report, and a cancel handle). It is BOUNDED on two axes:
+// a cap on simultaneously-active runs (a new run is refused past the cap) and a TTL after which a
+// TERMINATED run's record — including its event ring buffer — is evicted to reclaim memory (D7's
+// documented retention: buffers are dropped once the run terminates and its TTL elapses). The
+// registry is created via `createRunRegistry` and hung off the handler deps, never a module global,
+// so each server instance (and each test) owns an isolated registry with no cross-talk.
+export class ActiveRunLimitError extends Error {
+    constructor(limit) {
+        super(`active run limit reached (${String(limit)})`);
+        this.name = "ActiveRunLimitError";
+    }
+}
+const DEFAULT_MAX_ACTIVE_RUNS = 16;
+const DEFAULT_TERMINATED_TTL_MS = 600_000;
+function isTerminal(status) {
+    return status !== "running";
+}
+function evictExpired(state) {
+    const cutoff = state.now();
+    for (const [runId, record] of state.records) {
+        if (record.terminatedAt !== undefined && cutoff - record.terminatedAt >= state.ttlMs) {
+            state.records.delete(runId);
+        }
+    }
+}
+function countActive(state) {
+    let count = 0;
+    for (const record of state.records.values()) {
+        if (!isTerminal(record.status)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function registerRun(state, input) {
+    evictExpired(state);
+    if (countActive(state) >= state.maxActive) {
+        throw new ActiveRunLimitError(state.maxActive);
+    }
+    const record = {
+        runId: input.runId,
+        fingerprint: input.fingerprint,
+        modelId: input.modelId,
+        sink: input.sink,
+        status: "running",
+        report: undefined,
+        cancel: input.cancel,
+        appliable: undefined,
+        applyReport: undefined,
+        appliedAt: undefined,
+        terminatedAt: undefined,
+    };
+    state.records.set(input.runId, record);
+    return record;
+}
+function completeRun(state, runId, status, report, appliable) {
+    const record = state.records.get(runId);
+    if (record === undefined) {
+        return;
+    }
+    record.status = status;
+    record.report = report;
+    record.appliable = appliable;
+    record.terminatedAt = state.now();
+}
+export function createRunRegistry(options = {}) {
+    const state = {
+        records: new Map(),
+        maxActive: options.maxActiveRuns ?? DEFAULT_MAX_ACTIVE_RUNS,
+        ttlMs: options.terminatedTtlMs ?? DEFAULT_TERMINATED_TTL_MS,
+        now: options.now ?? Date.now,
+    };
+    return {
+        register: (input) => registerRun(state, input),
+        get: (runId) => {
+            evictExpired(state);
+            return state.records.get(runId);
+        },
+        complete: (runId, status, report, appliable) => {
+            completeRun(state, runId, status, report, appliable);
+        },
+        activeCount: () => {
+            evictExpired(state);
+            return countActive(state);
+        },
+        size: () => {
+            evictExpired(state);
+            return state.records.size;
+        },
+    };
+}

package/dist/ui/server.d.ts

@@ -0,0 +1,11 @@
+import { type Server } from "node:http";
+import { type UiHandlerDeps } from "./deps.js";
+export declare const DEFAULT_UI_PORT = 4319;
+export declare const UI_HOST = "127.0.0.1";
+export interface UiServerDeps {
+    readonly staticRoot: string;
+    readonly csp: string;
+    readonly port: number;
+    readonly handlerDeps?: UiHandlerDeps | undefined;
+}
+export declare function createUiServer(deps: UiServerDeps): Server;

package/dist/ui/server.js

@@ -0,0 +1,143 @@
+// The local UI BFF binds 127.0.0.1 only, applies security headers and CSP to every response,
+// rejects non-loopback Host/Origin headers, dispatches API routes through injected handlers,
+// and serves the static export from a contained root.
+import { createServer } from "node:http";
+import { extname, join } from "node:path";
+import { applySecurityHeaders } from "./headers.js";
+import { isAllowedHost } from "./host-check.js";
+import { resolveContainedPath, serveFile } from "./static.js";
+import { errorBody, isApiPath, matchRoute, methodNotAllowedBody, notFoundBody, STREAMING, } from "./routes.js";
+import { buildRedactor } from "./deps.js";
+import { createRunRegistry } from "./runs.js";
+import { createInMemoryUiStore } from "./store/index.js";
+export const DEFAULT_UI_PORT = 4319;
+export const UI_HOST = "127.0.0.1";
+function writeJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(body));
+}
+function isJsonRequest(req) {
+    const header = req.headers["content-type"];
+    const value = typeof header === "string" ? header : header?.[0];
+    return value?.split(";", 1)[0]?.trim().toLowerCase() === "application/json";
+}
+function hasCsrfHeader(req) {
+    const header = req.headers["x-keiko-csrf"];
+    const value = Array.isArray(header) ? header[0] : header;
+    return value === "1";
+}
+function rejectUnsupportedMediaType(res) {
+    writeJson(res, 415, errorBody("UNSUPPORTED_MEDIA_TYPE", "State-changing API requests must use JSON."));
+}
+function rejectCsrf(res) {
+    writeJson(res, 403, errorBody("FORBIDDEN_CSRF", "Missing state-changing request guard."));
+}
+// A minimal default deps object so a 3-arg server can still serve the deps-bound read routes (e.g.
+// `/api/models` and `/api/workspace`, which need no config) without a config or evidence dir. The
+// fallback UI store is in-memory: a 3-arg server is used by the Wave 1 host smoke and by tests that
+// never exercise the store routes, so an ephemeral in-memory store is the safe degraded shape.
+function fallbackDeps() {
+    return {
+        config: undefined,
+        configPresent: false,
+        evidenceStore: { put: () => "", list: () => [], get: () => undefined, delete: () => undefined },
+        env: {},
+        redactor: buildRedactor({}),
+        registry: createRunRegistry(),
+        modelPortFactory: () => undefined,
+        store: createInMemoryUiStore(),
+    };
+}
+function isStateChangingMethod(method) {
+    return (method === "POST" || method === "PATCH" || method === "PUT" || method === "DELETE");
+}
+// Returns true when the request was rejected (caller should return immediately).
+function rejectIfInvalidStateChange(req, res) {
+    if (!isJsonRequest(req)) {
+        rejectUnsupportedMediaType(res);
+        return true;
+    }
+    if (!hasCsrfHeader(req)) {
+        rejectCsrf(res);
+        return true;
+    }
+    return false;
+}
+async function dispatchApi(handlerDeps, req, res, method, url) {
+    const match = matchRoute(method, url.pathname);
+    if (match === undefined) {
+        writeJson(res, 404, notFoundBody());
+        return;
+    }
+    if (match === "method-not-allowed") {
+        writeJson(res, 405, methodNotAllowedBody());
+        return;
+    }
+    if (isStateChangingMethod(method) && rejectIfInvalidStateChange(req, res)) {
+        return;
+    }
+    const ctx = { req, res, params: match.params, url };
+    const outcome = await match.definition.handler(ctx, handlerDeps);
+    if (outcome === STREAMING) {
+        return;
+    }
+    writeJson(res, outcome.status, outcome.body);
+}
+async function serveStatic(res, staticRoot, pathname) {
+    const targets = pathname === "/"
+        ? ["/index.html"]
+        : extname(pathname) === ""
+            ? [pathname, `${pathname}.html`, `${pathname}/index.html`]
+            : [pathname];
+    for (const target of targets) {
+        const resolved = resolveContainedPath(staticRoot, target);
+        if (resolved !== undefined && (await serveFile(res, resolved))) {
+            return;
+        }
+    }
+    const indexPath = join(staticRoot, "index.html");
+    if (await serveFile(res, indexPath)) {
+        return;
+    }
+    writeJson(res, 404, errorBody("NOT_FOUND", "The requested resource was not found."));
+}
+function rejectForbiddenHost(res) {
+    const body = errorBody("FORBIDDEN_HOST", "Request host is not the local interface.");
+    writeJson(res, 403, body);
+}
+function handle(deps, handlerDeps, req, res) {
+    const url = new URL(req.url ?? "/", `http://${UI_HOST}`);
+    const apiPath = isApiPath(url.pathname);
+    applySecurityHeaders(res, deps.csp, apiPath);
+    if (!isAllowedHost(req, deps.port)) {
+        rejectForbiddenHost(res);
+        return;
+    }
+    const method = (req.method ?? "GET").toUpperCase();
+    const work = apiPath
+        ? dispatchApi(handlerDeps, req, res, method, url)
+        : serveStatic(res, deps.staticRoot, url.pathname);
+    void work.catch(() => {
+        if (!res.headersSent) {
+            writeJson(res, 500, errorBody("INTERNAL", "An unexpected error occurred."));
+        }
+        else {
+            res.end();
+        }
+    });
+}
+// Creates the BFF server. The caller binds it with `server.listen(deps.port, UI_HOST)` so it never
+// listens on a non-loopback interface. The previous PTY WebSocket upgrade handler is removed —
+// the terminal tool is now bounded-exec over plain HTTP (ADR-0018 D1/D8).
+export function createUiServer(deps) {
+    const handlerDeps = deps.handlerDeps ?? fallbackDeps();
+    const server = createServer((req, res) => {
+        handle(deps, handlerDeps, req, res);
+    });
+    server.on("upgrade", (_req, socket) => {
+        socket.write("HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n");
+        socket.destroy();
+    });
+    return server;
+}

package/dist/ui/sink.d.ts

@@ -0,0 +1,27 @@
+export interface StreamEvent {
+    readonly schemaVersion: "1";
+    readonly runId: string;
+    readonly fingerprint: string;
+    readonly seq: number;
+    readonly ts: number;
+    readonly type: string;
+}
+export interface SseWriter {
+    readonly write: (event: StreamEvent) => boolean | undefined;
+    readonly close: () => void;
+}
+export interface QueueEventSinkOptions {
+    readonly bufferCapacity?: number | undefined;
+}
+export declare class QueueEventSink {
+    private readonly buffer;
+    private readonly capacity;
+    private readonly writers;
+    private terminated;
+    readonly emit: (event: StreamEvent) => void;
+    constructor(options?: QueueEventSinkOptions);
+    attach(writer: SseWriter, afterSeq: number): () => void;
+    closeAll(): void;
+    isTerminated(): boolean;
+    buffered(afterSeq?: number): readonly StreamEvent[];
+}

package/dist/ui/sink.js

@@ -0,0 +1,80 @@
+// The QueueEventSink bridges the harness's push-only, synchronous EventSink (and the structurally
+// identical workflow WorkflowEventSink / BugWorkflowEventSink) to Server-Sent Events (ADR-0011 D7).
+// It satisfies all three sink shapes — each is `{ emit(event): void }` over an event that carries
+// the `{ schemaVersion, runId, fingerprint, seq, ts, type }` envelope — with one `emit` typed over
+// that structural envelope (no `any`; the concrete unions are assignable to it).
+//
+// It deliberately does NOT set `retainsRawContent`, so the harness emitter redacts every SENSITIVE
+// field before this sink ever receives an event (the browser only sees redacted events). Internally
+// it (a) appends each received event to a per-run BOUNDED ring buffer for replay-on-connect (oldest
+// dropped past the cap), and (b) fans the event out to any currently-attached SSE writers. A late or
+// reconnecting subscriber replays the buffer (respecting Last-Event-ID = the harness `seq`), then
+// receives live events, then a close after the terminal event.
+const DEFAULT_BUFFER_CAPACITY = 512;
+export class QueueEventSink {
+    // retainsRawContent is intentionally absent (never true): the harness must redact before emit.
+    buffer = [];
+    capacity;
+    writers = new Set();
+    terminated = false;
+    // Bound so the sink can be passed directly as an `EventSink`/`WorkflowEventSink`/`BugWorkflowEventSink`.
+    emit = (event) => {
+        this.buffer.push(event);
+        if (this.buffer.length > this.capacity) {
+            this.buffer.shift();
+        }
+        for (const writer of [...this.writers]) {
+            try {
+                const accepted = writer.write(event);
+                if (accepted === false) {
+                    this.writers.delete(writer);
+                    writer.close();
+                }
+            }
+            catch {
+                this.writers.delete(writer);
+                writer.close();
+            }
+        }
+    };
+    constructor(options = {}) {
+        this.capacity = options.bufferCapacity ?? DEFAULT_BUFFER_CAPACITY;
+    }
+    // Attaches an SSE writer: replays the buffered events with `seq` strictly greater than
+    // `afterSeq` (Last-Event-ID resume), then keeps the writer attached for live fan-out. Returns a
+    // detach function the caller invokes on client disconnect to stop fan-out and avoid leaks.
+    attach(writer, afterSeq) {
+        for (const event of this.buffer) {
+            if (event.seq > afterSeq) {
+                const accepted = writer.write(event);
+                if (accepted === false) {
+                    writer.close();
+                    return () => undefined;
+                }
+            }
+        }
+        this.writers.add(writer);
+        return () => {
+            this.writers.delete(writer);
+        };
+    }
+    // Closes and clears every attached writer (called once the run terminates). The ring buffer is
+    // retained for the registry TTL so a late subscriber can still replay history before eviction.
+    closeAll() {
+        if (this.terminated) {
+            return;
+        }
+        this.terminated = true;
+        for (const writer of this.writers) {
+            writer.close();
+        }
+        this.writers.clear();
+    }
+    isTerminated() {
+        return this.terminated;
+    }
+    // Snapshot of buffered events with `seq` strictly greater than `afterSeq` (inspection/replay aid).
+    buffered(afterSeq = -1) {
+        return this.buffer.filter((event) => event.seq > afterSeq);
+    }
+}

package/dist/ui/sse.d.ts

@@ -0,0 +1,7 @@
+import type { ServerResponse } from "node:http";
+import type { StreamEvent } from "./sink.js";
+import type { Redactor } from "./deps.js";
+export declare const SSE_HEADERS: Readonly<Record<string, string>>;
+export declare function frameEvent(event: StreamEvent, redactor: Redactor): string;
+export declare function readyMessage(): string;
+export declare function writeEvent(res: ServerResponse, event: StreamEvent, redactor: Redactor): boolean;

package/dist/ui/sse.js

@@ -0,0 +1,27 @@
+// Server-Sent Events framing for the run event stream (ADR-0011 D5/D7). One harness/workflow event
+// becomes one SSE message: `id:` is the event `seq` (the Last-Event-ID resume cursor), `event:` is
+// the event `type`, `data:` is the redacted event JSON on a single line, terminated by a blank line.
+// The event JSON is produced by `JSON.stringify`, which never emits a raw newline inside a string
+// (newlines are escaped as `\n`), so a single `data:` line is always valid — no regex, no manual
+// escaping. A synthetic `ready` message is sent after the buffered replay.
+export const SSE_HEADERS = {
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "Cache-Control": "no-store",
+    Connection: "keep-alive",
+};
+// Frames one event as an SSE message. The event is redacted (defense in depth: live events are
+// already redacted by the harness emitter, D7) before serialization.
+export function frameEvent(event, redactor) {
+    const data = JSON.stringify(redactor(event));
+    return `id: ${String(event.seq)}\nevent: ${event.type}\ndata: ${data}\n\n`;
+}
+// The synthetic message sent once the buffered replay completes, signalling the client that it is
+// now live. Carries no data payload.
+export function readyMessage() {
+    return `event: ready\ndata: {}\n\n`;
+}
+// Writes one framed event to the response stream. Returns Node's backpressure signal so the caller can
+// detach a slow client instead of letting the HTTP response buffer grow without bound.
+export function writeEvent(res, event, redactor) {
+    return res.write(frameEvent(event, redactor));
+}

package/dist/ui/static/404.html

@@ -0,0 +1 @@
+<!DOCTYPE html><!--ca_A01hy9W98aRvMZKdAw--><html lang="en"><head><meta charSet="utf-8"/><meta name="viewport" content="width=device-width, initial-scale=1"/><link rel="stylesheet" href="/_next/static/css/be7cb54d5c5673b6.css" data-precedence="next"/><link rel="preload" as="script" fetchPriority="low" href="/_next/static/chunks/webpack-4a462cecab786e93.js"/><script src="/_next/static/chunks/4bd1b696-c023c6e3521b1417.js" async=""></script><script src="/_next/static/chunks/255-d47fd57964443afe.js" async=""></script><script src="/_next/static/chunks/main-app-30679af7240d63e9.js" async=""></script><meta name="robots" content="noindex"/><title>404: This page could not be found.</title><title>Keiko</title><meta name="description" content="Keiko local developer-assist workspace."/><script src="/_next/static/chunks/polyfills-42372ed130431b0a.js" noModule=""></script></head><body><div hidden=""><!--$--><!--/$--></div><div style="font-family:system-ui,&quot;Segoe UI&quot;,Roboto,Helvetica,Arial,sans-serif,&quot;Apple Color Emoji&quot;,&quot;Segoe UI Emoji&quot;;height:100vh;text-align:center;display:flex;flex-direction:column;align-items:center;justify-content:center"><div><style>body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}</style><h1 class="next-error-h1" style="display:inline-block;margin:0 20px 0 0;padding:0 23px 0 0;font-size:24px;font-weight:500;vertical-align:top;line-height:49px">404</h1><div style="display:inline-block"><h2 style="font-size:14px;font-weight:400;line-height:49px;margin:0">This page could not be found.</h2></div></div></div><!--$--><!--/$--><script src="/_next/static/chunks/webpack-4a462cecab786e93.js" id="_R_" async=""></script><script>(self.__next_f=self.__next_f||[]).push([0])</script><script>self.__next_f.push([1,"1:\"$Sreact.fragment\"\n2:I[9766,[],\"\"]\n3:I[8924,[],\"\"]\n4:I[4431,[],\"OutletBoundary\"]\n6:I[5278,[],\"AsyncMetadataOutlet\"]\n8:I[4431,[],\"ViewportBoundary\"]\na:I[4431,[],\"MetadataBoundary\"]\nb:\"$Sreact.suspense\"\nd:I[7150,[],\"\"]\n:HL[\"/_next/static/css/be7cb54d5c5673b6.css\",\"style\"]\n"])</script><script>self.__next_f.push([1,"0:{\"P\":null,\"b\":\"ca-A01hy9W98aRvMZKdAw\",\"p\":\"\",\"c\":[\"\",\"_not-found\"],\"i\":false,\"f\":[[[\"\",{\"children\":[\"/_not-found\",{\"children\":[\"__PAGE__\",{}]}]},\"$undefined\",\"$undefined\",true],[\"\",[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"link\",\"0\",{\"rel\":\"stylesheet\",\"href\":\"/_next/static/css/be7cb54d5c5673b6.css\",\"precedence\":\"next\",\"crossOrigin\":\"$undefined\",\"nonce\":\"$undefined\"}]],[\"$\",\"html\",null,{\"lang\":\"en\",\"children\":[\"$\",\"body\",null,{\"children\":[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":\"$undefined\",\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]}]}]]}],{\"children\":[\"/_not-found\",[\"$\",\"$1\",\"c\",{\"children\":[null,[\"$\",\"$L2\",null,{\"parallelRouterKey\":\"children\",\"error\":\"$undefined\",\"errorStyles\":\"$undefined\",\"errorScripts\":\"$undefined\",\"template\":[\"$\",\"$L3\",null,{}],\"templateStyles\":\"$undefined\",\"templateScripts\":\"$undefined\",\"notFound\":\"$undefined\",\"forbidden\":\"$undefined\",\"unauthorized\":\"$undefined\"}]]}],{\"children\":[\"__PAGE__\",[\"$\",\"$1\",\"c\",{\"children\":[[[\"$\",\"title\",null,{\"children\":\"404: This page could not be found.\"}],[\"$\",\"div\",null,{\"style\":{\"fontFamily\":\"system-ui,\\\"Segoe UI\\\",Roboto,Helvetica,Arial,sans-serif,\\\"Apple Color Emoji\\\",\\\"Segoe UI Emoji\\\"\",\"height\":\"100vh\",\"textAlign\":\"center\",\"display\":\"flex\",\"flexDirection\":\"column\",\"alignItems\":\"center\",\"justifyContent\":\"center\"},\"children\":[\"$\",\"div\",null,{\"children\":[[\"$\",\"style\",null,{\"dangerouslySetInnerHTML\":{\"__html\":\"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}\"}}],[\"$\",\"h1\",null,{\"className\":\"next-error-h1\",\"style\":{\"display\":\"inline-block\",\"margin\":\"0 20px 0 0\",\"padding\":\"0 23px 0 0\",\"fontSize\":24,\"fontWeight\":500,\"verticalAlign\":\"top\",\"lineHeight\":\"49px\"},\"children\":404}],[\"$\",\"div\",null,{\"style\":{\"display\":\"inline-block\"},\"children\":[\"$\",\"h2\",null,{\"style\":{\"fontSize\":14,\"fontWeight\":400,\"lineHeight\":\"49px\",\"margin\":0},\"children\":\"This page could not be found.\"}]}]]}]}]],null,[\"$\",\"$L4\",null,{\"children\":[\"$L5\",[\"$\",\"$L6\",null,{\"promise\":\"$@7\"}]]}]]}],{},null,false]},null,false]},null,false],[\"$\",\"$1\",\"h\",{\"children\":[[\"$\",\"meta\",null,{\"name\":\"robots\",\"content\":\"noindex\"}],[[\"$\",\"$L8\",null,{\"children\":\"$L9\"}],null],[\"$\",\"$La\",null,{\"children\":[\"$\",\"div\",null,{\"hidden\":true,\"children\":[\"$\",\"$b\",null,{\"fallback\":null,\"children\":\"$Lc\"}]}]}]]}],false]],\"m\":\"$undefined\",\"G\":[\"$d\",[]],\"s\":false,\"S\":true}\n"])</script><script>self.__next_f.push([1,"9:[[\"$\",\"meta\",\"0\",{\"charSet\":\"utf-8\"}],[\"$\",\"meta\",\"1\",{\"name\":\"viewport\",\"content\":\"width=device-width, initial-scale=1\"}]]\n5:null\n"])</script><script>self.__next_f.push([1,"7:{\"metadata\":[[\"$\",\"title\",\"0\",{\"children\":\"Keiko\"}],[\"$\",\"meta\",\"1\",{\"name\":\"description\",\"content\":\"Keiko local developer-assist workspace.\"}]],\"error\":null,\"digest\":\"$undefined\"}\n"])</script><script>self.__next_f.push([1,"c:\"$7:metadata\"\n"])</script></body></html>

package/dist/ui/static/_next/static/ca-A01hy9W98aRvMZKdAw/_buildManifest.js

@@ -0,0 +1 @@
+self.__BUILD_MANIFEST=function(e,r,t){return{__rewrites:{afterFiles:[],beforeFiles:[],fallback:[]},__routerFilterStatic:{numItems:3,errorRate:1e-4,numBits:58,numHashes:14,bitArray:[1,1,0,e,0,e,e,e,r,e,e,e,r,e,r,e,r,r,e,r,e,r,e,r,r,e,r,r,e,r,e,e,e,e,e,e,e,e,e,e,e,r,e,r,e,r,r,e,e,e,r,e,r,r,r,r,e,e]},__routerFilterDynamic:{numItems:r,errorRate:1e-4,numBits:r,numHashes:null,bitArray:[]},"/_error":["static/chunks/pages/_error-cb2a52f75f2162e2.js"],sortedPages:["/_app","/_error"]}}(1,0,1e-4),self.__BUILD_MANIFEST_CB&&self.__BUILD_MANIFEST_CB();

package/dist/ui/static/_next/static/ca-A01hy9W98aRvMZKdAw/_ssgManifest.js

@@ -0,0 +1 @@
+self.__SSG_MANIFEST=new Set([]);self.__SSG_MANIFEST_CB&&self.__SSG_MANIFEST_CB()