@giovannijecha/jecode 0.8.2 → 0.8.3

package/dist/input-boundary.js

@@ -0,0 +1,80 @@
+// One bounded ingress for text that can become a user prompt.
+import { Buffer } from "node:buffer";
+import { StringDecoder } from "node:string_decoder";
+import { MAX_TEXT_CODE_UNITS } from "./text-boundary.js";
+export const MAX_PROMPT_CODE_UNITS = MAX_TEXT_CODE_UNITS;
+export const PROMPT_LIMIT_MESSAGE = `Prompt cannot exceed ${MAX_PROMPT_CODE_UNITS.toLocaleString("en-US")} UTF-16 code units`;
+export class PromptLimitError extends Error {
+    constructor() {
+        super(PROMPT_LIMIT_MESSAGE);
+        this.name = "PromptLimitError";
+    }
+}
+export function assertPromptLength(length) {
+    if (length > MAX_PROMPT_CODE_UNITS)
+        throw new PromptLimitError();
+}
+export function assertPromptAppend(current, added) {
+    if (added > MAX_PROMPT_CODE_UNITS - current)
+        throw new PromptLimitError();
+}
+/**
+ * Split raw UTF-8 input without letting one unterminated line grow past the
+ * prompt boundary. Newline, CRLF, and a final line without a newline match the
+ * line semantics used by batch mode.
+ */
+export async function* boundedInputLines(source) {
+    const decoder = new StringDecoder("utf8");
+    let line = "";
+    let pendingCr = false;
+    const append = (text, from, to) => {
+        const length = to - from;
+        assertPromptAppend(line.length, length);
+        if (length > 0)
+            line += text.slice(from, to);
+    };
+    const consume = function* (text) {
+        if (text === "")
+            return;
+        let from = 0;
+        if (pendingCr) {
+            if (text.startsWith("\n"))
+                from = 1;
+            pendingCr = false;
+            yield line;
+            line = "";
+        }
+        while (from < text.length) {
+            const cr = text.indexOf("\r", from);
+            const lf = text.indexOf("\n", from);
+            const newline = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
+            if (newline === -1) {
+                append(text, from, text.length);
+                return;
+            }
+            append(text, from, newline);
+            if (text[newline] === "\r" && newline + 1 === text.length) {
+                pendingCr = true;
+                return;
+            }
+            yield line;
+            line = "";
+            from = text[newline] === "\r" && text[newline + 1] === "\n"
+                ? newline + 2
+                : newline + 1;
+        }
+    };
+    for await (const chunk of source) {
+        const text = typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk));
+        yield* consume(text);
+    }
+    const tail = decoder.end();
+    if (tail !== "")
+        yield* consume(tail);
+    if (pendingCr) {
+        yield line;
+        line = "";
+    }
+    if (line !== "")
+        yield line;
+}

package/dist/main.js

@@ -1,7 +1,10 @@
 // Process entry point. The testable bootstrap lives in start.ts.
 import { start } from "./start.js";
+import { isProcessSignalError, withProcessShutdown } from "./process-shutdown.js";
 import { terminalText } from "./ui/terminal-text.js";
-start().catch((error) => {
+withProcessShutdown((signal) => start(process.argv.slice(2), { signal })).catch((error) => {
+    if (isProcessSignalError(error))
+        return;
     process.stderr.write(`jecode: ${terminalText(error.message)}\n`);
     process.exitCode = 1;
 });

package/dist/openai-oauth-callback.js

@@ -173,7 +173,7 @@ function resultPage(success) {
 let mascot;
 function mascotDataUri() {
     if (mascot === undefined) {
-        const file = new URL("../docs/assets/brand/jeco-256.png", import.meta.url);
+        const file = new URL("../assets/jeco-256.png", import.meta.url);
         mascot = `data:image/png;base64,${readFileSync(file).toString("base64")}`;
     }
     return mascot;

package/dist/process-shutdown.js

@@ -0,0 +1,52 @@
+// One process-wide cancellation boundary for operating-system signals.
+const SHUTDOWN_GRACE_MS = 2_000;
+const SIGNALS = [
+    ["SIGINT", 2],
+    ["SIGHUP", 1],
+    ["SIGTERM", 15],
+];
+export class ProcessSignalError extends Error {
+    signal;
+    exitCode;
+    constructor(signal, exitCode) {
+        super(`received ${signal}`);
+        this.name = "ProcessSignalError";
+        this.signal = signal;
+        this.exitCode = exitCode;
+    }
+}
+export function isProcessSignalError(error) {
+    return error instanceof ProcessSignalError;
+}
+/**
+ * Abort foreground work on the first fatal signal and reserve a bounded hard
+ * exit for work that ignores cancellation. A second signal exits immediately.
+ */
+export async function withProcessShutdown(work) {
+    const control = new AbortController();
+    let exitCode;
+    let forceTimer;
+    const listeners = [];
+    for (const [name, number] of SIGNALS) {
+        const listener = () => {
+            if (control.signal.aborted) {
+                process.exit(exitCode ?? 128 + number);
+            }
+            exitCode = 128 + number;
+            process.exitCode = exitCode;
+            control.abort(new ProcessSignalError(name, exitCode));
+            forceTimer = setTimeout(() => process.exit(exitCode), SHUTDOWN_GRACE_MS);
+        };
+        listeners.push([name, listener]);
+        process.on(name, listener);
+    }
+    try {
+        return await work(control.signal);
+    }
+    finally {
+        if (forceTimer !== undefined)
+            clearTimeout(forceTimer);
+        for (const [name, listener] of listeners)
+            process.off(name, listener);
+    }
+}

package/dist/providers/anthropic-stream.js

@@ -6,11 +6,13 @@
 // beyond display: thinking blocks carry a signature and must be echoed back
 // byte-for-byte on the next request.
 import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
+import { toolInputFromJson } from "./tool-input.js";
 export async function assembleAnthropic(events, onStream) {
     const blocks = new Map();
     const partialJson = new Map();
     const announcedTools = new Set();
     const sizes = { toolArguments: 0 };
+    const toolInputErrors = {};
     let stopReason;
     let stopDetails;
     let usage;
@@ -46,7 +48,10 @@ export async function assembleAnthropic(events, onStream) {
                 const pending = partialJson.get(event.index);
                 const block = blocks.get(event.index);
                 if (pending !== undefined && block !== undefined) {
-                    block.input = parseJsonObject(pending);
+                    const parsed = toolInputFromJson(pending);
+                    block.input = parsed.input;
+                    if (parsed.inputError !== undefined)
+                        toolInputErrors[event.index] = parsed.inputError;
                     partialJson.delete(event.index);
                 }
                 break;
@@ -69,10 +74,24 @@ export async function assembleAnthropic(events, onStream) {
     }
     if (!complete)
         throw new Error("anthropic stream ended before message_stop");
-    const content = [...blocks.entries()]
-        .sort(([a], [b]) => a - b)
-        .map(([, block]) => block);
-    return { content, stop_reason: stopReason, stop_details: stopDetails, usage };
+    const ordered = [...blocks.entries()].sort(([a], [b]) => a - b);
+    const content = ordered.map(([, block]) => block);
+    const orderedInputErrors = {};
+    for (let index = 0; index < ordered.length; index++) {
+        const sourceIndex = ordered[index]?.[0];
+        if (sourceIndex === undefined || toolInputErrors[sourceIndex] === undefined)
+            continue;
+        orderedInputErrors[index] = toolInputErrors[sourceIndex];
+    }
+    return {
+        content,
+        stop_reason: stopReason,
+        stop_details: stopDetails,
+        usage,
+        ...(Object.keys(orderedInputErrors).length === 0
+            ? {}
+            : { toolInputErrors: orderedInputErrors }),
+    };
 }
 function mergeUsage(before, after) {
     return after === undefined ? before : { ...before, ...after };
@@ -108,18 +127,3 @@ function applyDelta(blocks, partialJson, sizes, index, delta, onStream) {
             return;
     }
 }
-// Tool arguments arrive as a stream of JSON fragments. An empty accumulation
-// is a call with no arguments, not a malformed one.
-function parseJsonObject(text) {
-    if (text.trim() === "")
-        return {};
-    try {
-        const parsed = JSON.parse(text);
-        return typeof parsed === "object" && parsed !== null
-            ? parsed
-            : {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/providers/anthropic-wire.js

@@ -1,5 +1,6 @@
 // Translation between the normalized vocabulary and the Anthropic wire shape.
 // Pure functions, no I/O — which is what makes them testable without a key.
+import { toolInputFromValue } from "./tool-input.js";
 import { wireTokenCount } from "./wire-usage.js";
 export function toWireTool(tool) {
     return { name: tool.name, description: tool.description, input_schema: tool.input };
@@ -45,7 +46,8 @@ export function fromWireResponse(data) {
     const raw = Array.isArray(data.content) ? data.content : [];
     const content = [];
     let suppressedToolCall = false;
-    for (const item of raw) {
+    for (let index = 0; index < raw.length; index++) {
+        const item = raw[index];
         const block = item;
         if (block.type === "text" && typeof block.text === "string") {
             content.push({ kind: "text", text: block.text });
@@ -54,11 +56,14 @@ export function fromWireResponse(data) {
             if (data.stop_reason === "tool_use" &&
                 typeof block.id === "string" &&
                 typeof block.name === "string") {
+                const parsed = toolInputFromValue(block.input ?? {});
+                const inputError = data.toolInputErrors?.[index] ?? parsed.inputError;
                 content.push({
                     kind: "tool_call",
                     id: block.id,
                     name: block.name,
-                    input: (block.input ?? {}),
+                    input: parsed.input,
+                    ...(inputError === undefined ? {} : { inputError }),
                 });
             }
             else {

package/dist/providers/ollama-wire.js

@@ -6,6 +6,7 @@
 // Chat Completions differs on two points that matter here — a tool result is a
 // message of its own with role "tool", not a block inside a user turn, and tool
 // arguments travel as a JSON string rather than an object.
+import { toolInputFromJson } from "./tool-input.js";
 import { wireTokenCount } from "./wire-usage.js";
 export function toWireTool(tool) {
     return {
@@ -63,7 +64,12 @@ export function fromWireReply(reply) {
     const acceptsToolCalls = reply.finishReason === "tool_calls";
     if (acceptsToolCalls) {
         for (const call of reply.toolCalls) {
-            content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
+            content.push({
+                kind: "tool_call",
+                id: call.id,
+                name: call.name,
+                ...toolInputFromJson(call.args),
+            });
         }
     }
     const notice = stopNotice(reply);
@@ -104,17 +110,3 @@ export function stopNotice(reply) {
         ? "[truncated: hit the output limit — raise --max-tokens]"
         : undefined;
 }
-// A model that emits malformed JSON gets the empty object, which fails
-// validation in tools/args.ts with a message written for it to read. That is a
-// recoverable turn; throwing here would end the whole thing instead.
-function parseArgs(args) {
-    if (args.trim() === "")
-        return {};
-    try {
-        const parsed = JSON.parse(args);
-        return typeof parsed === "object" && parsed !== null ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/providers/ollama.js

@@ -90,6 +90,7 @@ export const ollama = {
             max_tokens: req.maxTokens,
             reasoning_effort: effort,
             stream: true,
+            stream_options: { include_usage: true },
         }, req.maxTokens, req.signal, req.onStatus);
         const reply = await assembleOllama(events, req.onStream);
         const notice = stopNotice(reply);

package/dist/providers/openai-wire.js

@@ -1,6 +1,7 @@
 // Translation between the normalized vocabulary and the OpenAI Responses wire
 // shape: a flat `input` list where tool calls and their outputs are top-level
 // items keyed by `call_id`, rather than blocks nested inside a message.
+import { toolInputFromJson } from "./tool-input.js";
 import { wireTokenCount } from "./wire-usage.js";
 export function toWireTool(tool) {
     return {
@@ -73,7 +74,7 @@ export function fromWireResponse(data, providerId = "openai") {
                     kind: "tool_call",
                     id: item.call_id,
                     name: item.name,
-                    input: parseArguments(item.arguments),
+                    ...toolInputFromJson(item.arguments),
                 });
             }
             else {
@@ -106,18 +107,3 @@ function normalizeUsage(data) {
         reasoningTokens: wireTokenCount(usage.output_tokens_details?.reasoning_tokens),
     };
 }
-// Arguments arrive as a JSON string and models vary in how they escape it, so
-// this always goes through a real parse — never string matching.
-function parseArguments(text) {
-    if (text === undefined || text === "")
-        return {};
-    try {
-        const parsed = JSON.parse(text);
-        return typeof parsed === "object" && parsed !== null
-            ? parsed
-            : {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/providers/tool-input.js

@@ -0,0 +1,17 @@
+// Provider-neutral validation for tool arguments crossing a wire boundary.
+export function toolInputFromJson(text) {
+    if (text === undefined || text.trim() === "")
+        return { input: {} };
+    try {
+        return toolInputFromValue(JSON.parse(text));
+    }
+    catch {
+        return { input: {}, inputError: "tool arguments were not valid JSON" };
+    }
+}
+export function toolInputFromValue(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return { input: value };
+    }
+    return { input: {}, inputError: "tool arguments must be a JSON object" };
+}

package/dist/sessions/codec.js

@@ -3,9 +3,10 @@
 // can become conversation or provider input.
 import { Buffer } from "node:buffer";
 import { CONTEXT_LIMITS } from "../context/projection.js";
+import { MAX_TEXT_CODE_UNITS } from "../text-boundary.js";
 export const SESSION_SCHEMA = 4;
 export const SESSION_FILE_LIMITS = Object.freeze({
-    text: 1_048_576,
+    text: MAX_TEXT_CODE_UNITS,
     metadataBytes: 64 * 1_024,
     nodeBytes: 20 * 1_024 * 1_024,
     jsonDepth: 24,

package/dist/sessions/lease.js

@@ -9,6 +9,13 @@ export function sessionLease(id, file, token) {
     let closed = false;
     return Object.freeze({
         id,
+        assertOwned: async () => {
+            if (closed)
+                throw new Error("session lease is closed");
+            const current = await readLease(file);
+            if (current !== token)
+                throw new Error("session lease is no longer owned by this process");
+        },
         close: async () => {
             if (closed)
                 return;

package/dist/sessions/runtime.js

@@ -8,11 +8,13 @@ export class SessionPersistence {
     #store;
     #sessionId;
     #lease;
+    #snapshot;
     #failure;
-    constructor(store, sessionId, lease) {
+    constructor(store, sessionId, lease, snapshot) {
         this.#store = store;
         this.#sessionId = sessionId;
         this.#lease = lease;
+        this.#snapshot = snapshot;
     }
     static fresh(store) {
         return new SessionPersistence(store, null);
@@ -26,7 +28,7 @@ export class SessionPersistence {
                 throw new Error("session has no resumable turn");
             return Object.freeze({
                 conversation,
-                persistence: new SessionPersistence(store, id, lease),
+                persistence: new SessionPersistence(store, id, lease, snapshot),
             });
         }
         catch (error) {
@@ -51,9 +53,14 @@ export class SessionPersistence {
                 const published = await this.#store.publish(conversation, true);
                 this.#lease = published.lease;
                 this.#sessionId = published.meta.id;
+                this.#snapshot = published;
                 return;
             }
-            await this.#store.checkpoint(this.#sessionId, conversation);
+            if (this.#lease === undefined || this.#snapshot === undefined) {
+                throw new Error("session persistence has no verified owner snapshot");
+            }
+            await this.#lease.assertOwned();
+            this.#snapshot = await this.#store.checkpoint(this.#snapshot, conversation);
         }
         catch (error) {
             this.#failure = error;
@@ -64,6 +71,7 @@ export class SessionPersistence {
         await this.#lease?.close();
         this.#lease = undefined;
         this.#sessionId = null;
+        this.#snapshot = undefined;
         this.#failure = undefined;
     }
     async close() {

package/dist/sessions/store.js

@@ -105,15 +105,18 @@ export class DurableSessionStore {
             if (!replacesHead && !extendsTree) {
                 throw new Error("session checkpoint cannot be recovered safely");
             }
-            head = {
+            head = Object.freeze({
                 version: SESSION_SCHEMA,
                 sequence: candidate.sequence,
                 nodeId: candidate.node.id,
                 parentId: candidate.node.parentId,
                 revision: candidate.node.revision,
                 updatedAt: candidate.updatedAt,
-            };
-            await atomicWrite(path.join(directory, "head.json"), encodeHead(head), { mode: FILE_MODE });
+            });
+            await atomicWrite(path.join(directory, "head.json"), encodeHead(head), {
+                mode: FILE_MODE,
+                validate: async () => assertDirectory(directory),
+            });
         }
         const nodes = stored.map((entry) => entry.node);
         const conversation = ConversationTree.restore(nodes, head.nodeId);
@@ -129,21 +132,21 @@ export class DurableSessionStore {
         const token = claim === true ? leaseToken() : undefined;
         const temporary = path.join(this.#bucket, `.${id}.${randomUUID()}.tmp`);
         const target = this.#sessionDirectory(id);
-        const meta = {
+        const meta = Object.freeze({
             version: SESSION_SCHEMA,
             id,
             workspaceRoot: this.workspaceRoot,
             workspaceDigest: this.workspaceDigest,
             createdAt: now,
-        };
-        const head = {
+        });
+        const head = Object.freeze({
             version: SESSION_SCHEMA,
             sequence: conversation.nodes.length,
             nodeId: active.id,
             parentId: active.parentId,
             revision: active.revision,
             updatedAt: now,
-        };
+        });
         try {
             await makePrivateDirectory(temporary);
             const nodes = path.join(temporary, "nodes");
@@ -169,12 +172,26 @@ export class DurableSessionStore {
         const lease = sessionLease(id, path.join(target, "active"), token);
         return Object.freeze({ ...snapshot, lease });
     }
-    async checkpoint(id, conversation) {
-        const previous = await this.load(id);
+    async checkpoint(previous, conversation) {
+        assertSnapshot(previous, this.workspaceRoot, this.workspaceDigest);
+        const id = previous.meta.id;
+        const directory = this.#sessionDirectory(id);
+        await assertDirectory(directory);
+        const nodesDirectory = path.join(directory, "nodes");
+        const validateNodesDirectory = async () => {
+            await assertDirectory(directory);
+            await assertDirectory(nodesDirectory);
+        };
+        await validateNodesDirectory();
+        const currentHead = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes));
+        if (!sameHead(currentHead, previous.head)) {
+            throw new Error("session head changed after its verified snapshot");
+        }
         const active = conversation.activeNode;
         if (active === undefined)
             throw new Error("an empty conversation cannot be checkpointed");
-        if (sameNode(active, previous.conversation.activeNode)) {
+        if (active === previous.conversation.activeNode &&
+            conversation.nodes === previous.conversation.nodes) {
             return Object.freeze({ ...previous, conversation });
         }
         const replacesHead = active.id === previous.head.nodeId &&
@@ -187,18 +204,23 @@ export class DurableSessionStore {
             throw new Error("session checkpoint does not extend its durable tree");
         }
         assertSharedNodes(previous.conversation, conversation, replacesHead ? active.id : undefined);
+        if (extendsTree) {
+            await assertMissingNode(path.join(nodesDirectory, nodeName(active.id)));
+        }
         const now = new Date().toISOString();
-        const head = {
+        const head = Object.freeze({
             version: SESSION_SCHEMA,
             sequence: previous.head.sequence + 1,
             nodeId: active.id,
             parentId: active.parentId,
             revision: active.revision,
             updatedAt: now,
-        };
-        const directory = this.#sessionDirectory(id);
-        await atomicWrite(path.join(directory, "nodes", nodeName(active.id)), encodeNode(active, head.sequence, now), { mode: FILE_MODE });
-        await atomicWrite(path.join(directory, "head.json"), encodeHead(head), { mode: FILE_MODE });
+        });
+        await atomicWrite(path.join(nodesDirectory, nodeName(active.id)), encodeNode(active, head.sequence, now), { mode: FILE_MODE, validate: async () => validateNodesDirectory() });
+        await atomicWrite(path.join(directory, "head.json"), encodeHead(head), {
+            mode: FILE_MODE,
+            validate: async () => assertDirectory(directory),
+        });
         return Object.freeze({ meta: previous.meta, head, conversation });
     }
     async claim(id) {
@@ -271,17 +293,44 @@ function assertSharedNodes(previous, next, replacedId) {
         if (node.id === replacedId)
             continue;
         const candidate = next.node(node.id);
-        if (candidate === undefined || normalizedNode(candidate) !== normalizedNode(node)) {
+        if (candidate !== node) {
             throw new Error("session checkpoint rewrites prior conversation history");
         }
     }
 }
-function normalizedNode(node) {
-    const encoded = JSON.parse(encodeNode(node, 1, "2026-01-01T00:00:00.000Z"));
-    return JSON.stringify(encoded.node);
+function assertSnapshot(snapshot, workspaceRoot, workspaceDigest) {
+    encodeMeta(snapshot.meta);
+    encodeHead(snapshot.head);
+    assertSessionId(snapshot.meta.id);
+    if (snapshot.meta.workspaceDigest !== workspaceDigest ||
+        workspaceKey(snapshot.meta.workspaceRoot) !== workspaceKey(workspaceRoot))
+        throw new Error("session snapshot belongs to a different workspace");
+    const active = snapshot.conversation.activeNode;
+    if (active === undefined ||
+        active.id !== snapshot.head.nodeId ||
+        active.parentId !== snapshot.head.parentId ||
+        active.revision !== snapshot.head.revision ||
+        snapshot.head.sequence < snapshot.conversation.nodes.length)
+        throw new Error("session snapshot does not match its verified head");
+}
+function sameHead(left, right) {
+    return left.version === right.version &&
+        left.sequence === right.sequence &&
+        left.nodeId === right.nodeId &&
+        left.parentId === right.parentId &&
+        left.revision === right.revision &&
+        left.updatedAt === right.updatedAt;
 }
-function sameNode(left, right) {
-    return right !== undefined && normalizedNode(left) === normalizedNode(right);
+async function assertMissingNode(file) {
+    try {
+        await lstat(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    throw new Error("session has an incomplete node outside its verified snapshot");
 }
 async function readNodes(directory) {
     await assertDirectory(directory);

package/dist/settings.js

@@ -1,5 +1,4 @@
 // Persistent, non-secret defaults for interactive and batch sessions.
-import { readFileSync } from "node:fs";
 import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
@@ -9,6 +8,7 @@ import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
 import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
+import { assertStoreText, readBoundedJsonSync, USER_STORE_LIMITS } from "./user-store.js";
 export { EFFORTS } from "./effort.js";
 let saved;
 export function readSettings() {
@@ -24,7 +24,9 @@ export async function updateSettings(patch) {
         await chmod(directory, 0o700);
     return withStoreLock(file, async () => {
         const next = normalize({ ...readStore(file), ...patch });
-        await atomicWrite(file, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+        const text = `${JSON.stringify(next, null, 2)}\n`;
+        assertStoreText(text, USER_STORE_LIMITS.settingsBytes);
+        await atomicWrite(file, text, { mode: 0o600 });
         saved = next;
         return file;
     });
@@ -41,7 +43,7 @@ export function reloadSettings() {
 }
 function readStore(file = settingsPath()) {
     try {
-        return normalize(JSON.parse(readFileSync(file, "utf8")));
+        return normalize(readBoundedJsonSync(file, USER_STORE_LIMITS.settingsBytes));
     }
     catch {
         // Missing, unreadable, and malformed stores all fall back safely. A bad
@@ -73,14 +75,14 @@ function normalize(value) {
 function modelsOf(value, providers) {
     if (!record(value))
         return undefined;
-    const models = Object.fromEntries(Object.entries(value).filter((entry) => providers.includes(entry[0]) && typeof entry[1] === "string" && entry[1].trim() !== ""));
+    const models = Object.fromEntries(Object.entries(value).filter((entry) => providers.includes(entry[0]) && boundedNonempty(entry[1], USER_STORE_LIMITS.model)));
     return Object.keys(models).length === 0 ? undefined : models;
 }
 function member(value, values) {
     return typeof value === "string" && values.includes(value) ? value : undefined;
 }
 function endpoint(value) {
-    if (typeof value !== "string")
+    if (!boundedNonempty(value, USER_STORE_LIMITS.endpoint))
         return undefined;
     try {
         return parseOllamaEndpoint(value).baseUrl;
@@ -89,6 +91,9 @@ function endpoint(value) {
         return undefined;
     }
 }
+function boundedNonempty(value, max) {
+    return typeof value === "string" && value.length <= max && value.trim() !== "";
+}
 function positiveInteger(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }