@giovannijecha/jecode 0.8.5 → 0.8.6

package/dist/providers/ollama-context.js

@@ -0,0 +1,42 @@
+// Cloud model capacity, with bounded metadata and conservative safety headroom.
+import { postJson } from "./http.js";
+import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
+const CACHE_MS = 30_000;
+const capacities = new Map();
+export async function ollamaContextWindow(model, headers, signal, onStatus) {
+    signal?.throwIfAborted();
+    const cached = capacities.get(model);
+    if (cached !== undefined && cached.expiresAt > Date.now())
+        return cached.value;
+    capacities.delete(model);
+    try {
+        const details = await postJson(`${OLLAMA_CLOUD_HOST}/api/show`, headers, { model }, signal, onStatus);
+        const tokens = modelCapacity(details);
+        if (tokens === undefined)
+            return undefined;
+        const value = Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
+        capacities.set(model, { value, expiresAt: Date.now() + CACHE_MS });
+        return value;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        // Missing metadata leaves budgeting to the controller's safe fallback.
+        return undefined;
+    }
+}
+function modelCapacity(value) {
+    if (!record(value) || !record(value["model_info"]))
+        return undefined;
+    const counts = Object.entries(value["model_info"])
+        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
+        .map(([, count]) => count);
+    return counts.length === 0 ? undefined : Math.max(...counts);
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/ollama-endpoint.js

@@ -1,40 +1,13 @@
-// Turning an Ollama host into one safe, normalized endpoint.
-export const OLLAMA_LOCAL_HOST = "http://127.0.0.1:11434";
+// The fixed API endpoint and recognition of its retired saved setting.
 export const OLLAMA_CLOUD_HOST = "https://ollama.com";
-export function parseOllamaEndpoint(value) {
-    let url;
+/** Recognize old official-cloud values without making endpoints configurable. */
+export function isLegacyOllamaCloudHost(value) {
+    if (typeof value !== "string")
+        return false;
     try {
-        url = new URL(value.trim());
+        return new URL(value.trim()).href.replace(/\/+$/, "") === OLLAMA_CLOUD_HOST;
     }
     catch {
-        throw new Error("Ollama endpoint must be an absolute HTTP(S) URL");
+        return false;
     }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error("Ollama endpoint must use HTTP or HTTPS");
-    }
-    if (url.username !== "" || url.password !== "") {
-        throw new Error("Ollama endpoint must not contain credentials");
-    }
-    if (url.search !== "" || url.hash !== "") {
-        throw new Error("Ollama endpoint must not contain a query or fragment");
-    }
-    const loopback = isExactLoopback(url.hostname);
-    if (url.protocol === "http:" && !loopback) {
-        throw new Error("Ollama endpoint must use HTTPS unless it is an exact loopback address");
-    }
-    const pathname = url.pathname.replace(/\/+$/, "");
-    return {
-        baseUrl: `${url.origin}${pathname === "" ? "" : pathname}`,
-        loopback,
-    };
-}
-export function ollamaConnectionKind(endpoint) {
-    if (endpoint.baseUrl === OLLAMA_CLOUD_HOST)
-        return "cloud";
-    if (endpoint.baseUrl === OLLAMA_LOCAL_HOST)
-        return "local";
-    return "custom";
-}
-function isExactLoopback(hostname) {
-    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
 }

package/dist/providers/ollama.js

@@ -1,58 +1,27 @@
-// Ollama, spoken through its OpenAI-compatible Chat Completions endpoint.
-//
-// One provider covers both deployments. An explicit session endpoint wins;
-// otherwise a configured key selects Ollama Cloud and no key selects the local
-// daemon. There is no default model — the catalogue is whatever the host has
-// pulled or the subscription grants — so the model has to be named with
-// --model.
+// Ollama Cloud through its OpenAI-compatible streaming Chat Completions API.
 import { requireSupportedEffort } from "../effort.js";
-import { getJson, postJson, postSse } from "./http.js";
+import { postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { assembleOllama } from "./ollama-stream.js";
+import { ollamaContextWindow } from "./ollama-context.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
-import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, ollamaConnectionKind, parseOllamaEndpoint, } from "./ollama-endpoint.js";
+import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
 import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
 const KEY = "OLLAMA_API_KEY";
 const ID = "ollama";
 // Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
 const OLLAMA_EFFORTS = ["low", "medium", "high"];
-let configuredHost;
-const CONTEXT_CACHE_MS = 30_000;
-const runtimeContextByEndpoint = new Map();
-const modelContextByEndpoint = new Map();
-/** Set the endpoint selected for this process. Undefined restores key-aware inference. */
-export function configureOllama(host) {
-    configuredHost = host === undefined ? undefined : parseOllamaEndpoint(host).baseUrl;
-}
-export function ollamaConnection() {
-    const inferred = configuredHost === undefined;
-    const endpoint = parseOllamaEndpoint(configuredHost ?? (apiKey() === undefined ? OLLAMA_LOCAL_HOST : OLLAMA_CLOUD_HOST));
-    return { ...endpoint, kind: ollamaConnectionKind(endpoint), inferred };
-}
 export const ollama = {
     id: ID,
     defaultModel: "",
     auth: { kind: "api-key", keyVar: KEY },
-    // The only provider whose key is conditional: a daemon on this machine is
-    // reached over loopback and asks for nothing, so demanding a key there
-    // would be an invented requirement.
     blocked() {
-        try {
-            const at = endpoint();
-            if (apiKey() !== undefined || at.loopback)
-                return undefined;
-            return `${KEY} is not set (required by ${at.baseUrl})`;
-        }
-        catch (error) {
-            return error.message;
-        }
+        return keyFor(KEY) === undefined ? `${KEY} is not set` : undefined;
     },
-    // Whatever the daemon has pulled, or whatever the subscription grants.
     async models(signal, onStatus) {
         try {
-            const at = endpoint();
-            return await listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
+            return await listModels(`${OLLAMA_CLOUD_HOST}/v1/models`, headers(), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
         }
         catch (error) {
             throwProviderError(ID, signal, error);
@@ -62,36 +31,12 @@ export const ollama = {
         return OLLAMA_EFFORTS;
     },
     async contextWindow(model, signal, onStatus) {
-        const at = endpoint();
-        const cacheKey = `${at.baseUrl}\u0000${model}`;
-        const runtime = cachedContext(runtimeContextByEndpoint, cacheKey);
-        if (runtime !== undefined)
-            return runtime;
-        const modelCapacity = cachedContext(modelContextByEndpoint, cacheKey);
-        const observed = await nativeContextWindow(at, model, modelCapacity, signal, onStatus);
-        if (observed?.runtime === true) {
-            rememberContext(runtimeContextByEndpoint, cacheKey, observed.value);
-        }
-        else if (observed !== undefined && modelCapacity === undefined) {
-            rememberContext(modelContextByEndpoint, cacheKey, observed.value);
-        }
-        return observed?.value;
-    },
-    location: () => {
-        try {
-            return endpoint().loopback ? "local" : "cloud";
-        }
-        catch {
-            return "cloud";
-        }
+        return ollamaContextWindow(model, headers(), signal, onStatus);
     },
     async send(req) {
-        const at = endpoint();
         const effort = requireSupportedEffort(req.model, req.effort, OLLAMA_EFFORTS);
-        // The OpenAI-compatible endpoint accepts this vocabulary for thinking
-        // models. Invalid levels are rejected locally instead of being rewritten.
         try {
-            const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
+            const events = await postSse(`${OLLAMA_CLOUD_HOST}/v1/chat/completions`, headers(), {
                 model: req.model,
                 messages: toWireMessages(req.system, req.messages),
                 tools: req.tools.map(toWireTool),
@@ -111,88 +56,9 @@ export const ollama = {
         }
     },
 };
-async function nativeContextWindow(at, model, fallback, signal, onStatus) {
-    try {
-        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
-        const allocated = runningContext(running, model);
-        if (allocated !== undefined)
-            return { value: usableContext(allocated), runtime: true };
-    }
-    catch (error) {
-        throwIfAborted(signal, error);
-    }
-    if (fallback !== undefined)
-        return { value: fallback, runtime: false };
-    try {
-        const details = await postJson(`${at.baseUrl}/api/show`, headers(at), { model }, signal, onStatus);
-        const capacity = modelCapacity(details);
-        return capacity === undefined
-            ? undefined
-            : { value: usableContext(capacity), runtime: false };
-    }
-    catch (error) {
-        throwIfAborted(signal, error);
-        return undefined;
-    }
-}
-function cachedContext(cache, key) {
-    const cached = cache.get(key);
-    if (cached === undefined)
-        return undefined;
-    if (cached.expiresAt > Date.now())
-        return cached.value;
-    cache.delete(key);
-    return undefined;
-}
-function rememberContext(cache, key, value) {
-    cache.set(key, { value, expiresAt: Date.now() + CONTEXT_CACHE_MS });
-}
-function runningContext(value, model) {
-    if (!record(value) || !Array.isArray(value["models"]))
-        return undefined;
-    for (const entry of value["models"]) {
-        if (!record(entry))
-            continue;
-        if (entry["name"] !== model && entry["model"] !== model)
-            continue;
-        if (validTokenCount(entry["context_length"]))
-            return entry["context_length"];
-    }
-    return undefined;
-}
-function modelCapacity(value) {
-    if (!record(value) || !record(value["model_info"]))
-        return undefined;
-    const capacities = Object.entries(value["model_info"])
-        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
-        .map(([, count]) => count);
-    return capacities.length === 0 ? undefined : Math.max(...capacities);
-}
-function validTokenCount(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) &&
-        value >= 4_096 && value <= 10_000_000;
-}
-function usableContext(tokens) {
-    return Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
-}
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function throwIfAborted(signal, error) {
-    if (signal?.aborted === true)
-        throw error;
-}
-function endpoint() {
-    return ollamaConnection();
-}
-function apiKey() {
-    return keyFor(KEY);
-}
-function headers(at) {
-    if (at.loopback)
-        return {};
-    const key = apiKey();
-    if (key !== undefined)
-        return { authorization: `Bearer ${key}` };
-    throw new Error(`${KEY} is not set (required by ${at.baseUrl})`);
+function headers() {
+    const key = keyFor(KEY);
+    if (key === undefined)
+        throw new Error(`${KEY} is not set`);
+    return { authorization: `Bearer ${key}` };
 }

package/dist/providers/openai-codex.js

@@ -2,6 +2,7 @@
 import { randomUUID } from "node:crypto";
 import { openAICodexAccount } from "../accounts.js";
 import { openAIAuthorization } from "../openai-account.js";
+import { providerLabel } from "../provider-label.js";
 import { applicationVersion } from "../version.js";
 import { EFFORTS, isEffort, requireSupportedEffort } from "../effort.js";
 import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
@@ -23,11 +24,10 @@ let contextByModel = new Map();
 export const openaiCodex = {
     id: ID,
     defaultModel: "",
-    auth: { kind: "oauth", account: ID, label: "ChatGPT" },
+    auth: { kind: "oauth", account: ID, label: providerLabel(ID) },
     blocked() {
-        return openAICodexAccount() === undefined ? "ChatGPT account is not connected" : undefined;
+        return openAICodexAccount() === undefined ? `${providerLabel(ID)} is not connected` : undefined;
     },
-    location: () => "cloud",
     async models(signal, onStatus) {
         try {
             const catalog = await loadCatalog(signal, onStatus);
@@ -140,7 +140,7 @@ function headers(authorization, sessionId, requestId) {
 function modelCatalog(value) {
     const source = record(value) && Array.isArray(value["models"]) ? value["models"] : undefined;
     if (source === undefined)
-        throw new Error("OpenAI Codex did not return a model list");
+        throw new Error(`${providerLabel(ID)} did not return a model list`);
     const seen = new Set();
     const models = source
         .slice(0, MAX_CATALOG_ITEMS)

package/dist/providers/openai.js

@@ -87,7 +87,6 @@ export const openai = {
     async contextWindow(model) {
         return openAIContextWindow(model);
     },
-    location: () => "cloud",
     async send(req) {
         const key = requireKey();
         const effort = requireSupportedEffort(req.model, req.effort, openAIEfforts(req.model));

package/dist/sessions/bucket.js

@@ -0,0 +1,55 @@
+// Stable workspace identity and directory anchors shared by session operations.
+import { createHash } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import * as path from "node:path";
+import { assertDirectoryAnchor, captureDirectDirectory, preparePrivateDirectory, } from "../directory-anchor.js";
+import { DIRECTORY_MODE, SESSION_NAME } from "./files.js";
+export class SessionBucket {
+    workspaceRoot;
+    workspaceDigest;
+    anchor;
+    #root;
+    constructor(workspaceRoot, root, anchor) {
+        this.workspaceRoot = workspaceRoot;
+        this.workspaceDigest = digestWorkspace(workspaceRoot);
+        this.#root = root;
+        this.anchor = anchor;
+        Object.freeze(this);
+    }
+    static async open(workspaceRoot, sessionsRoot) {
+        const canonical = await realpath(path.resolve(workspaceRoot));
+        const digest = digestWorkspace(canonical);
+        const root = await preparePrivateDirectory(path.resolve(sessionsRoot), "session storage root", DIRECTORY_MODE);
+        const anchor = await preparePrivateDirectory(path.join(root.path, digest), "workspace session directory", DIRECTORY_MODE);
+        return new SessionBucket(canonical, root, anchor);
+    }
+    directory(id) {
+        return path.join(this.anchor.path, id);
+    }
+    async captureSession(id) {
+        await this.assert();
+        return captureDirectDirectory(this.directory(id), "session directory");
+    }
+    async assertSession(anchor) {
+        await Promise.all([this.assert(), assertDirectoryAnchor(anchor)]);
+    }
+    async assert() {
+        await Promise.all([assertDirectoryAnchor(this.#root), assertDirectoryAnchor(this.anchor)]);
+    }
+    assertWorkspace(meta, id) {
+        if (meta.id !== id || meta.workspaceDigest !== this.workspaceDigest ||
+            workspaceKey(meta.workspaceRoot) !== workspaceKey(this.workspaceRoot))
+            throw new Error("session belongs to a different workspace");
+    }
+}
+function digestWorkspace(workspaceRoot) {
+    return createHash("sha256").update(workspaceKey(workspaceRoot)).digest("hex");
+}
+export function workspaceKey(workspaceRoot) {
+    const normalized = path.normalize(workspaceRoot);
+    return process.platform === "win32" ? normalized.toLocaleLowerCase("en-US") : normalized;
+}
+export function assertSessionId(id) {
+    if (!SESSION_NAME.test(id))
+        throw new Error("session id is invalid");
+}

package/dist/sessions/catalog-io.js

@@ -0,0 +1,162 @@
+// Head-tied resume listing and repairable catalogue-file IO.
+import * as path from "node:path";
+import { atomicWrite } from "../atomic.js";
+import { assertDirectoryAnchor } from "../directory-anchor.js";
+import { readStableDirectory } from "../stable-directory.js";
+import { catalogMatches, decodeSessionCatalog, encodeSessionCatalog, sameSessionHead, SESSION_CATALOG_BYTES, SESSION_CATALOG_FILE, SESSION_CHECKPOINT_FILE, } from "./catalog.js";
+import { decodeHead, decodeMeta, SESSION_FILE_LIMITS } from "./codec.js";
+import { FILE_MODE, readJson, SESSION_NAME } from "./files.js";
+import { leaseOwner, pidIsAlive, removeLease } from "./lease.js";
+const MAX_CATALOG_ENTRIES = 4_096;
+const CATALOG_READ_CONCURRENCY = 8;
+export class SessionCatalogIO {
+    #bucket;
+    #reader;
+    constructor(bucket, reader) {
+        this.#bucket = bucket;
+        this.#reader = reader;
+    }
+    async list(limit = 32) {
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 64) {
+            throw new Error("session catalogue limit is invalid");
+        }
+        await this.#bucket.assert();
+        const names = await catalogNames(this.#bucket.anchor);
+        const catalog = [];
+        for (let start = 0; start < names.length; start += CATALOG_READ_CONCURRENCY) {
+            const batch = await Promise.all(names.slice(start, start + CATALOG_READ_CONCURRENCY)
+                .map(async (id) => {
+                return await this.#catalogEntry(id);
+            }));
+            catalog.push(...batch.filter((entry) => entry !== undefined));
+        }
+        return catalog
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) || right.id.localeCompare(left.id))
+            .slice(0, limit);
+    }
+    async write(id, catalog, checkpointToken) {
+        const directory = this.#bucket.directory(id);
+        const directoryAnchor = await this.#bucket.captureSession(id);
+        const validateDirectory = async () => {
+            await this.#bucket.assertSession(directoryAnchor);
+        };
+        const validate = async () => {
+            await validateDirectory();
+            const currentHead = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes, undefined, validateDirectory));
+            if (!sameSessionHead(currentHead, catalog.head)) {
+                throw new Error("session head changed while updating its catalogue");
+            }
+        };
+        await atomicWrite(path.join(directory, SESSION_CATALOG_FILE), encodeSessionCatalog(catalog), { mode: FILE_MODE, validate });
+        if (checkpointToken !== undefined) {
+            await validateDirectory();
+            await removeLease(path.join(directory, SESSION_CHECKPOINT_FILE), checkpointToken);
+            await validateDirectory();
+        }
+    }
+    async #leaseIsActive(id, directory) {
+        if (directory !== undefined)
+            await this.#bucket.assertSession(directory);
+        else
+            await this.#bucket.assert();
+        const owner = await leaseOwner(path.join(this.#bucket.directory(id), "active"));
+        if (directory !== undefined)
+            await this.#bucket.assertSession(directory);
+        return owner !== undefined && pidIsAlive(owner.pid);
+    }
+    async #catalogEntry(id) {
+        try {
+            const directory = this.#bucket.directory(id);
+            const directoryAnchor = await this.#bucket.captureSession(id);
+            const validateDirectory = async () => {
+                await this.#bucket.assertSession(directoryAnchor);
+            };
+            const checkpointFile = path.join(directory, SESSION_CHECKPOINT_FILE);
+            // A second head read closes the only useful race: a checkpoint landing
+            // between the small record reads. A changing marker gets one retry.
+            for (let attempt = 0; attempt < 2; attempt++) {
+                await validateDirectory();
+                const checkpointBefore = await leaseOwner(checkpointFile);
+                try {
+                    const [metaValue, headValue, catalogValue] = await Promise.all([
+                        readJson(path.join(directory, "meta.json"), SESSION_FILE_LIMITS.metadataBytes, undefined, validateDirectory),
+                        readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes, undefined, validateDirectory),
+                        readJson(path.join(directory, SESSION_CATALOG_FILE), SESSION_CATALOG_BYTES, undefined, validateDirectory),
+                    ]);
+                    const meta = decodeMeta(metaValue);
+                    const head = decodeHead(headValue);
+                    const storedCatalog = decodeSessionCatalog(catalogValue);
+                    this.#bucket.assertWorkspace(meta, id);
+                    const confirmedHead = decodeHead(await readJson(path.join(directory, "head.json"), SESSION_FILE_LIMITS.metadataBytes, undefined, validateDirectory));
+                    await validateDirectory();
+                    const checkpointAfter = await leaseOwner(checkpointFile);
+                    if (!sameLease(checkpointBefore, checkpointAfter))
+                        continue;
+                    if (!sameSessionHead(head, confirmedHead) ||
+                        !catalogMatches(storedCatalog, meta, head))
+                        break;
+                    if (checkpointAfter !== undefined && !pidIsAlive(checkpointAfter.pid))
+                        break;
+                    const active = await this.#leaseIsActive(id, directoryAnchor) ||
+                        checkpointAfter !== undefined;
+                    return catalogEntry(storedCatalog, active);
+                }
+                catch {
+                    break;
+                }
+            }
+            // Missing, stale, or malformed summaries are rebuilt only while the
+            // session is idle. Selecting a session still performs this strict load.
+            const checkpoint = await leaseOwner(checkpointFile);
+            if (await this.#leaseIsActive(id, directoryAnchor) ||
+                (checkpoint !== undefined && pidIsAlive(checkpoint.pid)))
+                return undefined;
+            const repairLease = await this.#reader.claim(id);
+            let snapshot;
+            try {
+                snapshot = await this.#reader.load(id, repairLease);
+                await this.write(id, snapshot.catalog, checkpoint?.legacy === true ? undefined : checkpoint?.token).catch(() => undefined);
+            }
+            finally {
+                await repairLease.close();
+            }
+            const currentCheckpoint = await leaseOwner(checkpointFile);
+            const active = await this.#leaseIsActive(id, directoryAnchor) ||
+                (currentCheckpoint !== undefined && pidIsAlive(currentCheckpoint.pid));
+            return catalogEntry(snapshot.catalog, active);
+        }
+        catch {
+            // Corrupt, unsafe, active-without-a-summary, or foreign data never
+            // becomes a resume candidate.
+            return undefined;
+        }
+    }
+}
+async function catalogNames(directory) {
+    await assertDirectoryAnchor(directory);
+    const inspected = await readStableDirectory(directory.path, directory.path, {
+        maxEntries: MAX_CATALOG_ENTRIES + 1,
+    });
+    if (inspected.capped || inspected.entries.length > MAX_CATALOG_ENTRIES) {
+        throw new Error(`session catalogue exceeds ${MAX_CATALOG_ENTRIES} entries`);
+    }
+    return inspected.entries
+        .filter((entry) => entry.kind === "directory" && SESSION_NAME.test(entry.name))
+        .map((entry) => entry.name)
+        .sort((left, right) => right.localeCompare(left));
+}
+function catalogEntry(catalog, active) {
+    if (catalog.resumeNodeId === 0)
+        return undefined;
+    return Object.freeze({
+        id: catalog.id,
+        createdAt: catalog.createdAt,
+        updatedAt: catalog.head.updatedAt,
+        turns: catalog.turns,
+        preview: catalog.preview,
+        active,
+    });
+}
+function sameLease(left, right) {
+    return left?.token === right?.token && left?.legacy === right?.legacy;
+}

package/dist/sessions/catalog.js

@@ -11,7 +11,9 @@ import { decodeHead, encodeHead } from "./codec.js";
 export const SESSION_CATALOG_FILE = "catalog.json";
 export const SESSION_CHECKPOINT_FILE = ".checkpoint";
 export const SESSION_CATALOG_BYTES = 4 * 1_024;
-const CATALOG_SCHEMA = 1;
+// Older indexes can hide a node committed before a failed head write. Rebuild
+// them through strict loading instead of trusting their apparently current head.
+const CATALOG_SCHEMA = 2;
 const PREVIEW_CODE_UNITS = 160;
 export function sessionCatalog(meta, head, conversation) {
     assertActiveHead(head, conversation);