@hachej/boring-agent 0.4.3 → 0.4.4

package/dist/memory/optchat.js

@@ -1,3 +1,5 @@
+// Adapted from VictorTaelin/uniichat, Copyright 2026 Higher Order Company, Apache-2.0.
+// Changed: Pi-native tasks, documents, message adaptation and host memory controls. See ../../NOTICE and ../../licenses/Apache-2.0.txt.
 // OptChat memory as one native pi-durable extension, opt-in per conversation.
 // The Pi transcript is the append-only log and is never rewritten. While the extension is selected, `beforeRequest` shows
 // the model one view of everything before the current turn: a tiling of the log by summary-tree nodes, one `id+n|text`
@@ -15,7 +17,17 @@ export { OptChatLog, OptChatTree, advanceFold, emptyFold, leavesOf, renderView,
 export const OptChatNodes = defineDocFamily({
     kind: 'boring.memory.optchat.nodes', version: 1, family: true, scope: 'conversation', history: 'latest', fork: 'current', initial: () => ({ nodes: {} }),
 });
-/** Compactor bookkeeping of one conversation: the summarizer's calls and spend, and the last failure of each node (the retry spacing reads it; no timer does). */
+/** Seed memories, stored once per conversation and inherited by forks. They precede the Pi transcript in the memory only. */
+export const OptChatNotes = defineDoc({
+    kind: 'boring.memory.optchat.notes', version: 1, scope: 'conversation', history: 'latest', fork: 'current',
+    initial: () => ({ seeded: false, notes: [] }),
+});
+/** Memory-only tombstones. Values are leaf counts, never the forgotten content. Pi's transcript is unchanged. */
+export const OptChatEdits = defineDoc({
+    kind: 'boring.memory.optchat.edits', version: 1, scope: 'conversation', history: 'latest', fork: 'current',
+    initial: () => ({ revision: 0, forgotten: {} }),
+});
+/** Compactor bookkeeping of one conversation: calls, spend and the last failure of each node, including its retry streak. */
 export const OptChatState = defineDoc({
     kind: 'boring.memory.optchat.state', version: 1, scope: 'conversation', history: 'latest', fork: 'initial',
     initial: () => ({ calls: 0, usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 }, failures: {} }),
@@ -28,6 +40,7 @@ class Session {
     stored = new Map();
     tree;
     fold = emptyFold();
+    compactFold = emptyFold();
     /** Summary tasks may be created for leaves below this; the current turn's steps are held back while a request runs. */
     upTo = 0;
     lastRequest;
@@ -41,11 +54,33 @@ class Session {
         if (this.log.set(leaves) < before) {
             this.tree.reset();
             this.fold = emptyFold();
+            this.compactFold = emptyFold();
         }
     }
 }
 const message = (text) => ({ role: 'user', content: text.map(part => ({ type: 'text', text: part })), timestamp: Date.now() });
 const LIVE = ['pending', 'running', 'waiting'];
+function redacted(item) {
+    if (item.role === 'system')
+        return item;
+    if (item.role === 'assistant')
+        return { ...item, content: item.content.flatMap((part) => part.type === 'toolCall'
+                ? [{ type: 'toolCall', id: part.id, name: 'forgotten', arguments: {} }]
+                : part.type === 'text' ? [{ type: 'text', text: '(forgotten)' }] : []) };
+    if (item.role === 'toolResult')
+        return { ...item, toolName: 'forgotten', content: [{ type: 'text', text: '(forgotten)' }] };
+    return { ...item, content: '(forgotten)' };
+}
+/** Pi's TextContent has no per-block cache marker. Keep the reference's four-line blocks without inventing one. */
+function chatBlocks(lines) {
+    const rows = lines ? lines.split('\n') : [];
+    const blocks = ['<chat>\n'];
+    let i = 0;
+    for (; i + 4 <= rows.length; i += 4)
+        blocks.push(`${rows.slice(i, i + 4).join('\n')}\n`);
+    blocks.push(`${rows.slice(i).map(line => `${line}\n`).join('')}</chat>\n`);
+    return blocks;
+}
 const addUsage = (sum, usage) => {
     if (!sum)
         return structuredClone(usage);
@@ -68,12 +103,17 @@ const addUsage = (sum, usage) => {
 export function createOptChatMemory(options) {
     const nodeBytes = options.nodeBytes ?? DEFAULTS.nodeBytes, viewBytes = options.viewBytes ?? DEFAULTS.viewBytes, jobs = options.jobs ?? DEFAULTS.jobs;
     const tries = options.tries ?? DEFAULTS.tries, cap = options.cap ?? DEFAULTS.cap, retryMs = options.retryMs ?? DEFAULTS.retryMs, settleMs = options.settleTimeoutMs ?? DEFAULTS.settleTimeoutMs;
+    const compactBytes = options.compactBytes ?? DEFAULTS.compactBytes;
     const agentName = options.agentName ?? 'OptChat';
     const extensionName = options.name ?? 'boring.memory.optchat';
     const taskKind = `${extensionName}.node`;
     const system = compactPrompt(agentName);
     const scale = scaleLine(nodeBytes);
+    const notes = [...(options.notes ?? [])];
+    const logOptions = (seed, edits) => ({ notes: seed, forgotten: edits.forgotten, ...(options.workOf ? { workOf: options.workOf } : {}) });
     const sessions = new Map();
+    const naps = new Map();
+    const retryDelay = (failure) => Math.min(60_000, retryMs * 2 ** Math.min(30, (failure.attempts ?? 1) - 1));
     const aborter = new AbortController();
     const hostContext = withAbortSignal(aborter.signal, options.context);
     const session = (id) => {
@@ -85,6 +125,8 @@ export function createOptChatMemory(options) {
     /** Read the stored summaries. Tasks write them (in this process or another, before or after a restart), so every read goes to the documents. */
     async function loadStored(s, reader, context) {
         const total = s.log.leaves.length;
+        s.stored.clear();
+        s.tree.reset();
         for (let level = 0; span(level) <= total; level++) {
             const nodes = Math.floor(total / span(level));
             for (let shard = 0; shard * SHARD < nodes; shard++) {
@@ -100,14 +142,38 @@ export function createOptChatMemory(options) {
             throw new Error(`No conversation ${String(id)}`);
         return found;
     }
+    /** The compactor has an independent fold. Copy before advancing: native tasks and requests can overlap. */
+    function compactView(s, to) {
+        const cached = session(s.id).compactFold;
+        const fold = cached.T > to ? emptyFold() : { T: cached.T, size: cached.size, parts: cached.parts.map(part => ({ ...part })) };
+        return advanceFold(fold, s.tree, to, compactBytes);
+    }
     /** Bring a session up to date with the committed context and its stored summaries. */
     async function refresh(id) {
         const s = session(id);
         const view = await (await conversationOf(id)).context(options.context);
-        s.sync(leavesOf(view.messages, cap).leaves);
+        const seed = await seedNotes(id);
+        const edits = await memoryEdits(id);
+        s.sync(leavesOf(view.messages, cap, logOptions(seed, edits)).leaves);
         await loadStored(s, options.harness(), options.context);
         return s;
     }
+    async function memoryEdits(id) {
+        return await options.harness().snapshot(OptChatEdits, id, options.context) ?? { revision: 0, forgotten: {} };
+    }
+    async function seedNotes(id) {
+        const stored = await options.harness().snapshot(OptChatNotes, id, options.context);
+        if (stored?.seeded)
+            return stored.notes;
+        return (await conversationOf(id)).commit(async (tx) => {
+            const doc = await tx.doc(OptChatNotes, id);
+            if (!doc.seeded) {
+                doc.notes = [...notes];
+                doc.seeded = true;
+            }
+            return [...doc.notes];
+        }, options.context);
+    }
     // ---- The summarizer (runs inside the native task) ----------------------------------------------------------------------
     /** One node by the reference protocol (§4.2, §4.3): context first, then the step; over-long lines are resubmitted cut at the limit; the shortest wins. */
     async function askModel(job, runtimeModels, signal) {
@@ -131,7 +197,7 @@ export function createOptChatMemory(options) {
         const step = `For scale, this line is exactly ${scale.bytes} bytes:\n${scale.text}\n\n` + (job.level === 0
             ? `Compress this message into one line, in at most ${nodeBytes} bytes:\n${job.source[0]}`
             : `Merge these two lines into one, in at most ${nodeBytes} bytes:\n${lines.join('\n')}`);
-        const conversation = [message([`<chat>\n${job.context}\n</chat>`, step])];
+        const conversation = [message([...chatBlocks(job.context), step])];
         const attempts = [];
         let usage, calls = 0, spender;
         try {
@@ -186,29 +252,48 @@ export function createOptChatMemory(options) {
                 // A private view of this conversation: a request may be folding and rendering the shared session right now.
                 const s = new Session(id, nodeBytes);
                 const load = async () => {
-                    s.sync(leavesOf((await runtime.context(id, context)).messages, cap).leaves);
+                    const seed = (await runtime.snapshot(OptChatNotes, id, context))?.notes ?? [];
+                    const edits = await runtime.snapshot(OptChatEdits, id, context) ?? { revision: 0, forgotten: {} };
+                    s.sync(leavesOf((await runtime.context(id, context)).messages, cap, logOptions(seed, edits)).leaves);
                     await loadStored(s, runtime, context);
+                    return edits.revision;
                 };
-                await load();
+                const revision = await load();
                 const ready = () => s.log.fp(level, index) === of && (level === 0 || (s.tree.text(level - 1, 2 * index) !== undefined && s.tree.text(level - 1, 2 * index + 1) !== undefined));
                 if (!ready() || s.tree.text(level, index) !== undefined)
                     return stale(); // the history changed, a child is missing, or the node needs no summary
-                const to = Math.min(upTo, s.log.leaves.length);
-                if (s.fold.T > to)
-                    s.fold = emptyFold();
-                advanceFold(s.fold, s.tree, to, viewBytes);
+                const to = Math.min(upTo, index * span(level));
+                const shared = session(id);
+                shared.sync(s.log.leaves);
+                const fold = compactView(s, to);
+                if (fold.size > compactBytes)
+                    return stale(); // admission will build preceding parents before trying this node again
+                if (fold.T >= shared.compactFold.T)
+                    shared.compactFold = fold;
                 const source = level === 0 ? [s.log.leaves[index].line] : [s.tree.text(level - 1, 2 * index), s.tree.text(level - 1, 2 * index + 1)];
-                const job = { conversationId: id, level, index, range: [index * span(level), (index + 1) * span(level) - 1], source, context: bareLines(s.fold, s.tree, level === 0 ? index : (index + 1) * span(level)), nodeBytes };
-                const summary = await askModel(job, runtime.models, runtime.signal);
+                const job = { conversationId: id, level, index, range: [index * span(level), (index + 1) * span(level) - 1], source, context: bareLines(fold, s.tree, to), nodeBytes };
+                let summary;
+                try {
+                    summary = await askModel(job, runtime.models, runtime.signal);
+                }
+                catch (error) {
+                    if (runtime.signal.aborted)
+                        throw error;
+                    summary = { error, calls: 0 }; // model resolution can fail before any request is sent
+                }
                 await load();
                 if (!ready())
                     return stale(summary); // the history changed while the model ran: its line is dropped, its spend is kept
                 let firstFailure = false;
                 await runtime.commit(async (tx) => {
                     const state = await bookkeeping(tx, id, summary);
+                    const edits = await tx.doc(OptChatEdits, id);
+                    if (edits.revision !== revision)
+                        return { status: 'terminal', outcome: { status: 'completed', result: { built: false } } };
                     if (summary.text === undefined) {
-                        firstFailure = state.failures[`${level}:${index}`]?.of !== of;
-                        state.failures[`${level}:${index}`] = { at: Date.now(), of, error: String(summary.error?.message ?? summary.error) };
+                        const previous = state.failures[`${level}:${index}`];
+                        firstFailure = previous?.of !== of;
+                        state.failures[`${level}:${index}`] = { at: Date.now(), of, attempts: firstFailure ? 1 : (previous?.attempts ?? 1) + 1, error: String(summary.error?.message ?? summary.error) };
                         return { status: 'terminal', outcome: { status: 'failed', error: { message: state.failures[`${level}:${index}`].error } } };
                     }
                     const doc = await tx.doc(OptChatNodes, id, shardKey(level, index), 0);
@@ -242,6 +327,8 @@ export function createOptChatMemory(options) {
                     continue;
                 if (level > 0 && (s.tree.text(level - 1, 2 * index) === undefined || s.tree.text(level - 1, 2 * index + 1) === undefined))
                     continue;
+                if (compactView(s, index * span(level)).size > compactBytes)
+                    break;
                 found.push({ level, index });
             }
         }
@@ -250,7 +337,7 @@ export function createOptChatMemory(options) {
     /**
      * Make sure every node that can be built has one live background task, up to `jobs` live tasks of the conversation. Host
      * admission only: Pi schedules and runs the tasks. One live task per node key (found by scanning native tasks in the same
-     * commit that creates them); a node whose last failure is inside `retryMs` is left for the next trigger.
+     * commit that creates them); a node inside its backoff window waits for the idle admission loop.
      */
     async function admit(s, skip) {
         const wanted = candidates(s).map(({ level, index }) => ({ level, index, of: s.log.fp(level, index) }));
@@ -276,7 +363,7 @@ export function createOptChatMemory(options) {
                 if (found.has(key) || skip.has(key))
                     continue;
                 const failure = failures[nodeKey(node.level, node.index)];
-                if (failure && failure.of === node.of && now - failure.at < retryMs) {
+                if (failure && failure.of === node.of && now - failure.at < retryDelay(failure)) {
                     waiting++;
                     continue;
                 }
@@ -301,22 +388,45 @@ export function createOptChatMemory(options) {
             cancel();
         }
     }
-    async function nap(id) {
-        const s = await refresh(id);
-        s.upTo = s.log.leaves.length;
-        const skip = new Set();
-        for (;;) {
-            const { live } = await admit(s, skip);
-            if (live.size === 0)
+    /** Abortable host wait between admission attempts. Pi still owns each node task and its recovery. */
+    async function pause(ms) {
+        if (aborter.signal.aborted)
+            return;
+        await new Promise(resolve => {
+            const done = () => { clearTimeout(timer); aborter.signal.removeEventListener('abort', done); resolve(); };
+            const timer = setTimeout(done, Math.max(1, ms));
+            aborter.signal.addEventListener('abort', done, { once: true });
+        });
+    }
+    async function drain(id) {
+        while (!aborter.signal.aborted) {
+            const s = await refresh(id);
+            s.upTo = s.log.leaves.length;
+            const { live } = await admit(s, new Set());
+            if (live.size > 0) {
+                if (!await settleAny([...live.values()], undefined, hostContext))
+                    return;
+                continue;
+            }
+            const failures = (await options.harness().snapshot(OptChatState, id, options.context))?.failures ?? {};
+            const delays = candidates(s).flatMap(({ level, index }) => {
+                const failure = failures[nodeKey(level, index)];
+                return failure && failure.of === s.log.fp(level, index) ? [failure.at + retryDelay(failure) - Date.now()] : [];
+            });
+            if (delays.length === 0)
                 return;
-            const done = await settleAny([...live.values()], undefined, hostContext);
-            if (!done)
-                return; // disposed
-            if (!done.built)
-                skip.add(done.key);
-            await loadStored(s, options.harness(), options.context);
+            await pause(Math.min(...delays));
         }
     }
+    function nap(id) {
+        const key = String(id);
+        const existing = naps.get(key);
+        if (existing)
+            return existing;
+        const running = drain(id).finally(() => { naps.delete(key); });
+        naps.set(key, running);
+        return running;
+    }
     /** Wait until every line of the view is a summary (§6). Never shows cut text: on timeout the rest shows the placeholder. */
     async function settle(s, covered, context) {
         const deadline = Date.now() + settleMs, skip = new Set();
@@ -339,6 +449,45 @@ export function createOptChatMemory(options) {
                 skip.add(done.key);
         }
     }
+    /** Context can copy an earlier fact into a later summary. Invalidate those too, atomically with the tombstone. */
+    async function forgetMessage(id, messageIndex) {
+        if (!Number.isInteger(messageIndex) || messageIndex < 0)
+            throw new Error('Invalid message index');
+        const conversation = await conversationOf(id);
+        const seed = await seedNotes(id);
+        for (;;) {
+            const edits = await memoryEdits(id);
+            const messages = (await conversation.context(options.context)).messages;
+            if (messageIndex >= messages.length || messages[messageIndex].role === 'system')
+                throw new Error('No forgettable message at that index');
+            const ordinal = messages.slice(0, messageIndex).filter(item => item.role !== 'system').length;
+            if (edits.forgotten[String(ordinal)] !== undefined)
+                return;
+            const { leaves, before } = leavesOf(messages, cap, logOptions(seed, edits));
+            const start = before[messageIndex], end = before[messageIndex + 1];
+            const changed = await conversation.commit(async (tx) => {
+                const doc = await tx.doc(OptChatEdits, id);
+                if (doc.revision !== edits.revision)
+                    return false;
+                doc.forgotten[String(ordinal)] = end - start;
+                doc.revision++;
+                const state = await tx.doc(OptChatState, id);
+                for (let level = 0; span(level) <= leaves.length; level++) {
+                    for (let index = Math.floor(start / span(level)); (index + 1) * span(level) <= leaves.length; index++) {
+                        const shard = await tx.doc(OptChatNodes, id, shardKey(level, index), 0);
+                        delete shard.nodes[String(index)];
+                        delete state.failures[nodeKey(level, index)];
+                    }
+                }
+                return true;
+            }, options.context);
+            if (!changed)
+                continue;
+            sessions.delete(String(id));
+            void nap(id).catch(() => { });
+            return;
+        }
+    }
     // ---- The extension -----------------------------------------------------------------------------------------------------
     const text = (value) => ({ output: [{ type: 'text', text: value }] });
     const zoomTool = defineTool({
@@ -363,30 +512,53 @@ export function createOptChatMemory(options) {
         hooks: [
             hook(GenerationTask, {
                 beforeRequest: async (request, api, context) => {
-                    const { leaves, before } = leavesOf(request.messages, cap);
-                    const last = request.messages.findLastIndex(item => item.role === 'user');
-                    const covered = last < 0 ? 0 : before[last];
-                    if (covered === 0)
-                        return undefined; // nothing came before this turn
-                    const s = session(api.conversationId);
-                    s.sync(leaves);
-                    s.upTo = covered;
-                    if (s.fold.T > covered)
-                        s.fold = emptyFold();
-                    const started = Date.now();
-                    const settled = await settle(s, covered, context);
-                    const view = renderView(s.fold, s.tree);
-                    const messages = request.messages.flatMap((item, index) => {
-                        if (index < last)
-                            return item.role === 'system' ? [item] : [];
-                        if (index > last)
-                            return [item];
-                        const user = item;
-                        const body = typeof user.content === 'string' ? [{ type: 'text', text: user.content }] : user.content;
-                        return [{ ...user, content: [{ type: 'text', text: view }, ...body] }];
-                    });
-                    s.lastRequest = { at: new Date().toISOString(), covered, requestMessages: messages.length, logMessages: request.messages.length, viewBytes: byteLength(view), waitedMs: Date.now() - started, settled };
-                    return { messages };
+                    for (;;) {
+                        const seed = await seedNotes(api.conversationId);
+                        const edits = await memoryEdits(api.conversationId);
+                        const { leaves, before } = leavesOf(request.messages, cap, logOptions(seed, edits));
+                        const last = request.messages.findLastIndex(item => item.role === 'user' || (item.role !== 'system' && options.workOf?.(item)));
+                        const covered = last < 0 ? 0 : before[last];
+                        if (covered === 0 && Object.keys(edits.forgotten).length === 0 && !request.messages.some(item => options.workOf?.(item)))
+                            return undefined;
+                        const cached = session(api.conversationId);
+                        cached.sync(leaves);
+                        const s = new Session(api.conversationId, nodeBytes);
+                        s.sync(leaves);
+                        s.upTo = covered;
+                        if (cached.fold.T <= covered)
+                            s.fold = { T: cached.fold.T, size: cached.fold.size, parts: cached.fold.parts.map(part => ({ ...part })) };
+                        const started = Date.now();
+                        const settled = await settle(s, covered, context);
+                        if ((await memoryEdits(api.conversationId)).revision !== edits.revision)
+                            continue;
+                        const view = renderView(s.fold, s.tree);
+                        const blocks = chatBlocks(view.split('\n').slice(1, -1).join('\n')).map(text => ({ type: 'text', text }));
+                        let ordinal = 0;
+                        const calls = new Set();
+                        const messages = request.messages.flatMap((item, index) => {
+                            const forgotten = item.role !== 'system' && edits.forgotten[String(ordinal++)] !== undefined;
+                            if (index < last)
+                                return item.role === 'system' ? [item] : [];
+                            const retained = forgotten ? redacted(item) : item;
+                            const work = item.role !== 'system' && options.workOf?.(item);
+                            // A report can start midway through a tool batch. Never send results without their calls.
+                            const normalize = (index === last && work && retained.role !== 'user') || (retained.role === 'toolResult' && !calls.has(retained.toolCallId));
+                            const current = normalize ? message([leavesOf([retained], Infinity, { workOf: () => !!work }).leaves[0].line]) : retained;
+                            if (current.role === 'assistant')
+                                for (const part of current.content)
+                                    if (part.type === 'toolCall')
+                                        calls.add(part.id);
+                            if (index > last || current.role === 'system')
+                                return [current];
+                            if (current.role === 'assistant')
+                                return [{ ...current, content: [...blocks, ...current.content] }];
+                            const body = typeof current.content === 'string' ? [{ type: 'text', text: current.content }] : current.content;
+                            return [{ ...current, content: [...blocks, ...body] }];
+                        });
+                        cached.lastRequest = { at: new Date().toISOString(), covered, requestMessages: messages.length, logMessages: request.messages.length, viewBytes: byteLength(view), waitedMs: Date.now() - started, settled };
+                        cached.fold = s.fold;
+                        return { messages };
+                    }
                 },
                 // A finished answer: once the run has committed it, create its summary tasks (background, so they never hold the run) so the next request finds its view ready.
                 onYield: (_answer, api) => {
@@ -414,7 +586,7 @@ export function createOptChatMemory(options) {
             const state = await options.harness().snapshot(OptChatState, id, options.context);
             const failures = Object.entries(state?.failures ?? {}).filter(([key, failure]) => { const [level, index] = key.split(':').map(Number); return failure.of === s.log.fp(level, index); }).map(([, failure]) => failure);
             const busy = (await options.harness().inspect(options.context)).tasks.filter(task => task.record.kind === taskKind && task.record.conversationId === id).length;
-            const retrying = failures.filter(failure => Date.now() - failure.at < retryMs).length;
+            const retrying = failures.filter(failure => Date.now() - failure.at < retryDelay(failure)).length;
             const latest = failures.reduce((best, failure) => !best || failure.at > best.at ? failure : best, undefined);
             return {
                 leaves: s.log.leaves.length, summaries,
@@ -426,7 +598,8 @@ export function createOptChatMemory(options) {
         },
         async zoom(id, nth, n) { return zoomText((await refresh(id)).tree, nth, n); },
         async date(id, nth) { return dateText((await refresh(id)).log, nth); },
+        forgetMessage,
         forget(id) { sessions.delete(String(id)); },
-        async dispose() { aborter.abort(); },
+        async dispose() { aborter.abort(); await Promise.allSettled(naps.values()); },
     };
 }

package/licenses/Apache-2.0.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Higher Order Company
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.