@someonegg/agent-hub 0.0.0-stage → 0.7.0

package/dist/server/server/adapters/codex/jsonl-catalog-source.js

@@ -0,0 +1,84 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { opaqueIdForPath } from "../../security/opaque-id.js";
+import { isExpectedIoError } from "./io-errors.js";
+const MAX_DEPTH = 8;
+const ROLLOUT_NAME = /^rollout-[A-Za-z0-9][A-Za-z0-9._-]*\.jsonl$/;
+export class JsonlCatalogSource {
+    configDirectory;
+    archivedDescriptors;
+    constructor(configDirectory, archivedDescriptors = new Map()) {
+        this.configDirectory = configDirectory;
+        this.archivedDescriptors = archivedDescriptors;
+    }
+    async discover() {
+        const entries = [];
+        const diagnostics = [];
+        const unreadable = (code) => {
+            if (diagnostics.length < 50)
+                diagnostics.push({
+                    code,
+                    severity: "warning",
+                    message: "A session directory or rollout could not be read.",
+                    ordinal: null,
+                });
+        };
+        const scan = async (directory, relative, archived, depth) => {
+            let children;
+            try {
+                children = await readdir(directory, { withFileTypes: true });
+            }
+            catch (error) {
+                if (!isExpectedIoError(error))
+                    throw error;
+                if (depth !== 0 || error.code !== "ENOENT")
+                    unreadable("session_root_unreadable");
+                return;
+            }
+            for (const child of children) {
+                const path = join(directory, child.name);
+                const sourceRelativePath = `${relative}/${child.name}`;
+                try {
+                    const linkedInfo = child.isSymbolicLink() ? await stat(path) : undefined;
+                    const info = linkedInfo ?? child;
+                    if (info.isDirectory()) {
+                        if (depth < MAX_DEPTH)
+                            await scan(path, sourceRelativePath, archived, depth + 1);
+                        continue;
+                    }
+                    if (!info.isFile() || !ROLLOUT_NAME.test(child.name))
+                        continue;
+                    const cached = archived ? this.archivedDescriptors.get(path) : undefined;
+                    if (cached !== undefined) {
+                        entries.push({ descriptor: cached });
+                        continue;
+                    }
+                    const metadata = linkedInfo ?? (await stat(path));
+                    if (!metadata.isFile())
+                        continue;
+                    entries.push({
+                        descriptor: {
+                            id: opaqueIdForPath(path),
+                            path,
+                            sourceRelativePath,
+                            archived,
+                            size: metadata.size,
+                            mtimeMs: metadata.mtimeMs,
+                        },
+                    });
+                }
+                catch (error) {
+                    if (!isExpectedIoError(error))
+                        throw error;
+                    unreadable("rollout_unavailable");
+                }
+            }
+        };
+        for (const name of ["sessions", "archived_sessions"]) {
+            await scan(resolve(this.configDirectory, name), name, name === "archived_sessions", 0);
+        }
+        entries.sort((a, b) => a.descriptor.path.localeCompare(b.descriptor.path));
+        return { entries, diagnostics };
+    }
+}
+//# sourceMappingURL=jsonl-catalog-source.js.map

package/dist/server/server/adapters/codex/limits.js

@@ -0,0 +1,2 @@
+export * from "../shared/limits.js";
+//# sourceMappingURL=limits.js.map

package/dist/server/server/adapters/codex/message-normalizer.js

@@ -0,0 +1,66 @@
+import { truncateText } from "../../domain/session-text.js";
+import { isObject } from "../shared/jsonl-decoder.js";
+import { MAX_MESSAGE_CHARS } from "./limits.js";
+import { nonEmptyString } from "./value-readers.js";
+export function eventMessage(ordinal, timestamp, payload) {
+    const type = nonEmptyString(payload.type);
+    if (type === "user_message" || type === "agent_message") {
+        const markdown = nonEmptyString(payload.message);
+        if (markdown === null)
+            return null;
+        const role = type === "user_message" ? "user" : "assistant";
+        const phase = type === "agent_message" ? normalizePhase(payload.phase) : null;
+        return messageItem(ordinal, timestamp, role, phase, null, markdown);
+    }
+    if (type !== "item_completed" || !isObject(payload.item))
+        return null;
+    const item = payload.item;
+    const itemType = nonEmptyString(item.type);
+    if (itemType === "UserMessage") {
+        const markdown = itemContentText(item.content, "text");
+        return markdown === null ? null : messageItem(ordinal, timestamp, "user", null, null, markdown);
+    }
+    if (itemType === "AgentMessage") {
+        const markdown = itemContentText(item.content, "Text");
+        return markdown === null
+            ? null
+            : messageItem(ordinal, timestamp, "assistant", normalizePhase(item.phase), null, markdown);
+    }
+    if (itemType !== "Plan")
+        return null;
+    const markdown = nonEmptyString(item.text);
+    return markdown === null
+        ? null
+        : messageItem(ordinal, timestamp, "assistant", "response", "plan", markdown);
+}
+function messageItem(ordinal, timestamp, role, phase, itemType, markdown) {
+    return {
+        kind: "message",
+        id: `message-${ordinal}`,
+        ordinal,
+        timestamp,
+        role,
+        phase,
+        itemType,
+        markdown: truncateText(markdown, MAX_MESSAGE_CHARS).text,
+    };
+}
+function itemContentText(value, acceptedType) {
+    if (!Array.isArray(value))
+        return null;
+    const text = value
+        .filter(isObject)
+        .filter((part) => part.type === acceptedType)
+        .map((part) => nonEmptyString(part.text))
+        .filter((part) => part !== null)
+        .join("\n\n");
+    return text.length === 0 ? null : text;
+}
+function normalizePhase(value) {
+    if (value === "commentary")
+        return "update";
+    if (value === "final" || value === "final_answer")
+        return "response";
+    return null;
+}
+//# sourceMappingURL=message-normalizer.js.map

package/dist/server/server/adapters/codex/response-item-parser.js

@@ -0,0 +1,64 @@
+import { isObject } from "../shared/jsonl-decoder.js";
+import { parseUserInputQuestions } from "./user-input-normalizer.js";
+import { nonEmptyString } from "./value-readers.js";
+export function parseResponseItem(ordinal, timestamp, payload) {
+    const userInput = userInputRequest(ordinal, timestamp, payload);
+    if (userInput !== null)
+        return { kind: "user_input_request", value: userInput };
+    const output = toolOutput(ordinal, timestamp, payload);
+    if (output !== null)
+        return { kind: "tool_output", value: output };
+    return { kind: "ignored" };
+}
+function userInputRequest(ordinal, timestamp, payload) {
+    if (payload.type !== "function_call" || payload.name !== "request_user_input")
+        return null;
+    const callId = nonEmptyString(payload.call_id);
+    if (callId === null)
+        return null;
+    const questions = parseUserInputQuestions(payload.arguments);
+    return {
+        callId,
+        ordinal,
+        timestamp,
+        questions: questions ?? [],
+        malformed: questions === null,
+    };
+}
+function toolOutput(ordinal, timestamp, payload) {
+    const type = nonEmptyString(payload.type);
+    if (type !== "function_call_output" && type !== "custom_tool_call_output")
+        return null;
+    const callId = nonEmptyString(payload.call_id);
+    if (callId === null)
+        return null;
+    return {
+        callId,
+        ordinal,
+        timestamp,
+        output: toolOutputText(payload.output),
+        failed: payload.success === false || payload.status === "failed",
+    };
+}
+function serializeText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined)
+        return null;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return null;
+    }
+}
+function toolOutputText(value) {
+    if (!Array.isArray(value))
+        return serializeText(value);
+    const parts = value
+        .filter(isObject)
+        .map((part) => nonEmptyString(part.text) ?? nonEmptyString(part.output_text) ?? serializeText(part))
+        .filter((part) => part !== null);
+    return parts.length === 0 ? serializeText(value) : parts.join("\n\n");
+}
+//# sourceMappingURL=response-item-parser.js.map

package/dist/server/server/adapters/codex/rollout-descriptor.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rollout-descriptor.js.map

package/dist/server/server/adapters/codex/session-index-reader.js

@@ -0,0 +1,101 @@
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import { normalizeSessionTitle } from "../../domain/session-text.js";
+import { MAX_JSONL_LINE_BYTES } from "./limits.js";
+export class SessionIndexReader {
+    #path;
+    #fingerprint = null;
+    #threadNames = new Map();
+    constructor(configDirectory) {
+        this.#path = join(configDirectory, "session_index.jsonl");
+    }
+    async refresh() {
+        let handle;
+        try {
+            handle = await open(this.#path, "r");
+            const info = await handle.stat();
+            const fingerprint = { size: info.size, mtimeMs: info.mtimeMs };
+            if (sameFingerprint(this.#fingerprint, fingerprint))
+                return;
+            const threadNames = info.size === 0
+                ? new Map()
+                : await readCompleteRecords(handle.createReadStream({ start: 0, end: info.size - 1, autoClose: false }));
+            this.#threadNames = threadNames;
+            this.#fingerprint = fingerprint;
+        }
+        catch {
+            this.#threadNames = new Map();
+            this.#fingerprint = null;
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+    }
+    threadName(id) {
+        return this.#threadNames.get(id) ?? null;
+    }
+}
+async function readCompleteRecords(stream) {
+    const threadNames = new Map();
+    let parts = [];
+    let bytes = 0;
+    let droppingOversizedLine = false;
+    for await (const rawChunk of stream) {
+        const chunk = typeof rawChunk === "string" ? Buffer.from(rawChunk) : rawChunk;
+        let cursor = 0;
+        while (cursor < chunk.length) {
+            const newline = chunk.indexOf(0x0a, cursor);
+            const end = newline === -1 ? chunk.length : newline;
+            const part = chunk.subarray(cursor, end);
+            if (!droppingOversizedLine) {
+                if (bytes + part.length <= MAX_JSONL_LINE_BYTES) {
+                    if (part.length > 0)
+                        parts.push(part);
+                    bytes += part.length;
+                }
+                else {
+                    parts = [];
+                    bytes = 0;
+                    droppingOversizedLine = true;
+                }
+            }
+            if (newline === -1)
+                break;
+            if (!droppingOversizedLine)
+                consumeLine(Buffer.concat(parts, bytes), threadNames);
+            parts = [];
+            bytes = 0;
+            droppingOversizedLine = false;
+            cursor = newline + 1;
+        }
+    }
+    // An unterminated tail may still be in flight, so it is deliberately ignored.
+    return threadNames;
+}
+function consumeLine(line, threadNames) {
+    try {
+        const value = JSON.parse(line.toString("utf8"));
+        if (!isObject(value))
+            return;
+        const id = nonEmptyString(value.id);
+        const threadName = nonEmptyString(value.thread_name);
+        if (id === null || threadName === null)
+            return;
+        const normalized = normalizeSessionTitle(threadName);
+        if (normalized !== null)
+            threadNames.set(id, normalized);
+    }
+    catch {
+        // session_index.jsonl is advisory; malformed records do not affect sessions.
+    }
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sameFingerprint(left, right) {
+    return left !== null && left.size === right.size && left.mtimeMs === right.mtimeMs;
+}
+//# sourceMappingURL=session-index-reader.js.map

package/dist/server/server/adapters/codex/session-manager.js

@@ -0,0 +1,51 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { TmuxLauncher } from "../../interaction/tmux-launcher.js";
+import { exitSteps, resolveDirectory } from "../shared/session-management.js";
+import { codexBindingCommand } from "./interaction-parser.js";
+const execute = promisify(execFile);
+export class CodexSessionManager {
+    configDirectory;
+    tmux;
+    constructor(configDirectory, tmux = new TmuxLauncher()) {
+        this.configDirectory = configDirectory;
+        this.tmux = tmux;
+    }
+    resolveDirectory = resolveDirectory;
+    isValidNativeId(nativeId) {
+        return /^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}$/i.test(nativeId);
+    }
+    launch({ operationId, workingDirectory, worktree, yolo, resumeNativeId, projectDirectory, taskName, }) {
+        if (resumeNativeId !== undefined && !this.isValidNativeId(resumeNativeId))
+            throw new Error("Invalid resume identity");
+        return this.tmux.launch(operationId, workingDirectory, [
+            "env",
+            `CODEX_HOME=${this.configDirectory}`,
+            "codex",
+            ...(resumeNativeId ? ["resume", resumeNativeId] : []),
+            "--no-daemon",
+            "--no-alt-screen",
+            ...(worktree ? ["--worktree"] : []),
+            ...(yolo ? ["--yolo"] : []),
+            codexBindingCommand(operationId, projectDirectory, taskName ?? null),
+        ]);
+    }
+    exitSteps = exitSteps;
+    async archive(nativeId) {
+        await this.#command(["archive", nativeId]);
+    }
+    async delete(nativeId) {
+        await this.#command(["delete", nativeId, "--force"]);
+    }
+    async #command(args) {
+        if (!this.isValidNativeId(args[1]))
+            throw new Error("Session has no valid native UUID");
+        await execute("codex", args, {
+            env: { ...process.env, CODEX_HOME: this.configDirectory },
+            timeout: 25_000,
+            maxBuffer: 64 * 1024,
+        });
+    }
+}
+export const createCodexSessionManager = (configDirectory, socket) => new CodexSessionManager(configDirectory, new TmuxLauncher(socket));
+//# sourceMappingURL=session-manager.js.map

package/dist/server/server/adapters/codex/session-normalizer.js

@@ -0,0 +1,175 @@
+import { normalizeSessionTitle, sessionTitleFromMarkdown } from "../../domain/session-text.js";
+import { isObject } from "../shared/jsonl-decoder.js";
+import { codexInteraction } from "./interaction-parser.js";
+import { MAX_SESSION_DIAGNOSTICS } from "./limits.js";
+import { eventMessage } from "./message-normalizer.js";
+import { parseResponseItem } from "./response-item-parser.js";
+import { normalizeUserInputRequest, normalizeUserInputResponse, } from "./user-input-normalizer.js";
+import { nonEmptyString } from "./value-readers.js";
+export class DefaultSessionNormalizer {
+    create(descriptor) {
+        return {
+            descriptor,
+            timeline: [],
+            pendingUserInputRequests: new Map(),
+            decoderDiagnostics: [],
+            normalizerDiagnostics: [],
+            hasFirstUserMessage: false,
+            firstUserTitle: null,
+        };
+    }
+    append(state, records, decoderDiagnostics) {
+        const nextDecoderDiagnostics = decoderDiagnostics.slice(0, MAX_SESSION_DIAGNOSTICS);
+        const decoderDiagnosticsUnchanged = sameDiagnostics(state.decoderDiagnostics, nextDecoderDiagnostics);
+        if (records.length === 0 && decoderDiagnosticsUnchanged) {
+            return state;
+        }
+        const items = [];
+        const pendingUserInputRequests = new LazyMap(state.pendingUserInputRequests);
+        const normalizerDiagnostics = [...state.normalizerDiagnostics];
+        for (const record of records) {
+            consumeRecord(record, items, pendingUserInputRequests, normalizerDiagnostics);
+        }
+        let hasFirstUserMessage = state.hasFirstUserMessage;
+        let firstTitle = state.firstUserTitle;
+        for (const item of items) {
+            if (!hasFirstUserMessage && item.kind === "message" && item.role === "user") {
+                hasFirstUserMessage = true;
+                firstTitle = sessionTitleFromMarkdown(item.markdown);
+            }
+        }
+        return {
+            ...state,
+            timeline: items.length === 0 ? state.timeline : [...state.timeline, ...items],
+            pendingUserInputRequests: pendingUserInputRequests.result,
+            decoderDiagnostics: decoderDiagnosticsUnchanged
+                ? state.decoderDiagnostics
+                : nextDecoderDiagnostics,
+            normalizerDiagnostics,
+            hasFirstUserMessage,
+            firstUserTitle: firstTitle,
+        };
+    }
+    materialize(state, metadata, origin = DEFAULT_SESSION_ORIGIN) {
+        const diagnostics = combinedDiagnostics(state);
+        const warningCount = diagnostics.filter((diagnostic) => diagnostic.severity !== "info").length;
+        const title = normalizeSessionTitle(metadata.title) ?? state.firstUserTitle ?? "Untitled session";
+        const session = {
+            id: state.descriptor.id,
+            sourceId: metadata.threadId,
+            origin,
+            title,
+            workingDirectory: metadata.workingDirectory,
+            projectDirectory: metadata.projectDirectory,
+            createdAt: metadata.createdAt,
+            updatedAt: metadata.updatedAt,
+            archived: metadata.archived,
+            parentId: metadata.parentThreadId,
+            childIds: [],
+            subagent: metadata.subagent ?? null,
+            warningCount,
+            diagnostics,
+        };
+        return {
+            session,
+            timeline: state.timeline,
+            interaction: codexInteraction(),
+        };
+    }
+}
+function combinedDiagnostics(state) {
+    const remaining = MAX_SESSION_DIAGNOSTICS - state.decoderDiagnostics.length;
+    return [...state.decoderDiagnostics, ...state.normalizerDiagnostics.slice(0, remaining)];
+}
+function sameDiagnostics(left, right) {
+    return (left.length === right.length &&
+        left.every((item, index) => {
+            const candidate = right[index];
+            return (candidate !== undefined &&
+                item.code === candidate.code &&
+                item.severity === candidate.severity &&
+                item.message === candidate.message &&
+                item.ordinal === candidate.ordinal);
+        }));
+}
+class LazyMap {
+    original;
+    #copy;
+    constructor(original) {
+        this.original = original;
+    }
+    get result() {
+        return this.#copy ?? this.original;
+    }
+    set(key, value) {
+        if (this.result.has(key) && this.result.get(key) === value)
+            return;
+        (this.#copy ??= new Map(this.original)).set(key, value);
+    }
+    delete(key) {
+        if (!this.result.has(key))
+            return false;
+        return (this.#copy ??= new Map(this.original)).delete(key);
+    }
+}
+const DEFAULT_SESSION_ORIGIN = {
+    sourceType: "test",
+    agent: "test",
+    runtimeName: "Test",
+    runtimeVersion: null,
+};
+function consumeRecord(record, items, pendingUserInputRequests, diagnostics) {
+    const timestamp = nonEmptyString(record.value.timestamp);
+    const payload = record.value.payload;
+    if (!isObject(payload)) {
+        if (typeof record.value.type !== "string")
+            appendDiagnostic(diagnostics, {
+                code: "unknown_record",
+                severity: "info",
+                message: "A record without a recognized type was reduced to a safe diagnostic.",
+                ordinal: record.ordinal,
+            });
+        return;
+    }
+    if (record.value.type === "response_item") {
+        consumeParsedResponse(parseResponseItem(record.ordinal, timestamp, payload), items, pendingUserInputRequests, diagnostics);
+    }
+    else if (record.value.type === "event_msg") {
+        const message = eventMessage(record.ordinal, timestamp, payload);
+        if (message)
+            items.push(message);
+    }
+}
+function appendDiagnostic(diagnostics, diagnostic) {
+    if (diagnostics.length < MAX_SESSION_DIAGNOSTICS) {
+        diagnostics.push(diagnostic);
+    }
+}
+function consumeParsedResponse(parsed, items, pendingUserInputRequests, diagnostics) {
+    switch (parsed.kind) {
+        case "tool_output": {
+            if (pendingUserInputRequests.delete(parsed.value.callId)) {
+                addUserInput(normalizeUserInputResponse(parsed.value), items, diagnostics);
+            }
+            break;
+        }
+        case "user_input_request":
+            pendingUserInputRequests.set(parsed.value.callId, parsed.value);
+            addUserInput(normalizeUserInputRequest(parsed.value), items, diagnostics);
+            break;
+        case "ignored":
+            break;
+    }
+}
+function addUserInput(accumulated, items, diagnostics) {
+    items.push(accumulated.item);
+    if (accumulated.malformed) {
+        appendDiagnostic(diagnostics, {
+            code: "invalid_user_input",
+            severity: "warning",
+            message: "A request_user_input call or output had an unsupported payload shape.",
+            ordinal: accumulated.item.ordinal,
+        });
+    }
+}
+//# sourceMappingURL=session-normalizer.js.map

package/dist/server/server/adapters/codex/subagent-identity.js

@@ -0,0 +1,9 @@
+export function nonEmptySubagentIdentity(fields) {
+    return Object.values(fields).some((field) => field !== null) ? fields : null;
+}
+export function taskNameFromSubagentPath(agentPath) {
+    if (agentPath === null)
+        return null;
+    return agentPath.split("/").filter(Boolean).at(-1) ?? null;
+}
+//# sourceMappingURL=subagent-identity.js.map

package/dist/server/server/adapters/codex/user-input-normalizer.js

@@ -0,0 +1,121 @@
+import { MAX_PREVIEW_CHARS, truncateText } from "../../domain/session-text.js";
+import { isObject } from "../shared/jsonl-decoder.js";
+import { nonEmptyString } from "./value-readers.js";
+export function normalizeUserInputRequest(request) {
+    return {
+        item: {
+            kind: "user_input",
+            stage: "request",
+            id: `user-input-${request.ordinal}`,
+            ordinal: request.ordinal,
+            timestamp: request.timestamp,
+            callId: request.callId,
+            questions: request.questions,
+        },
+        malformed: request.malformed,
+    };
+}
+export function normalizeUserInputResponse(output) {
+    const parsed = parseResponse(output.output);
+    const base = {
+        kind: "user_input",
+        stage: "response",
+        id: `user-input-${output.ordinal}`,
+        ordinal: output.ordinal,
+        timestamp: output.timestamp,
+        callId: output.callId,
+    };
+    if (parsed.kind === "answered") {
+        return {
+            item: { ...base, outcome: "answered", answers: parsed.answers },
+            malformed: false,
+        };
+    }
+    if (parsed.kind === "aborted") {
+        return {
+            item: { ...base, outcome: "aborted" },
+            malformed: false,
+        };
+    }
+    return {
+        item: {
+            ...base,
+            outcome: "unavailable",
+            summary: truncateText(output.output ?? "User input response was unavailable.", MAX_PREVIEW_CHARS).text,
+        },
+        malformed: true,
+    };
+}
+export function parseUserInputQuestions(value) {
+    const object = parseObject(value);
+    if (object === null || !Array.isArray(object.questions))
+        return null;
+    if (object.questions.length < 1 || object.questions.length > 3)
+        return null;
+    const questions = object.questions.map(parseQuestion);
+    if (!questions.every((question) => question !== null))
+        return null;
+    const parsed = questions;
+    return new Set(parsed.map((question) => question.id)).size === parsed.length ? parsed : null;
+}
+function parseQuestion(value) {
+    if (!isObject(value) || !Array.isArray(value.options))
+        return null;
+    if (value.options.length < 2 || value.options.length > 3)
+        return null;
+    const id = nonEmptyString(value.id);
+    const header = nonEmptyString(value.header);
+    const question = nonEmptyString(value.question);
+    const options = value.options.map((option) => {
+        if (!isObject(option))
+            return null;
+        const label = nonEmptyString(option.label);
+        const description = nonEmptyString(option.description);
+        return label === null || description === null ? null : { label, description };
+    });
+    if (id === null ||
+        header === null ||
+        question === null ||
+        !options.every((option) => option !== null))
+        return null;
+    const parsedOptions = options;
+    if (new Set(parsedOptions.map((option) => option.label)).size !== parsedOptions.length) {
+        return null;
+    }
+    return { id, header, question, options: parsedOptions };
+}
+function parseResponse(value) {
+    if (value === null)
+        return { kind: "unavailable" };
+    if (value.trim().toLocaleLowerCase("en-US").startsWith("aborted by user")) {
+        return { kind: "aborted" };
+    }
+    const object = parseObject(value);
+    if (object === null || !isObject(object.answers))
+        return { kind: "unavailable" };
+    const answers = [];
+    for (const [questionId, rawAnswer] of Object.entries(object.answers)) {
+        if (!isObject(rawAnswer) || !Array.isArray(rawAnswer.answers)) {
+            return { kind: "unavailable" };
+        }
+        const values = rawAnswer.answers.filter((answer) => typeof answer === "string");
+        if (values.length !== rawAnswer.answers.length)
+            return { kind: "unavailable" };
+        answers.push({ questionId, answers: values });
+    }
+    return { kind: "answered", answers };
+}
+function parseObject(value) {
+    if (isObject(value))
+        return value;
+    if (typeof value !== "string")
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return isObject(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=user-input-normalizer.js.map