tricu

io-v2-protocol.ts (3536B)

---

 // Inert wire decoding, not execution, resolution or a capability declaration.
 // The caller retains the action and returned borrowed handles across collection.
 export type Node<H> = { kind: 'leaf' } | { kind: 'stem'; child: H } | { kind: 'fork'; left: H; right: H };
 export interface Reader<H> { observe(handle: H): { node: Node<H> }; }
 export type Action<H> = { kind: 'core'; code: number; payload: H }
   | { kind: 'request'; group: string; revision: number; operation: string; arguments: H };
 
 export function canonicalNat<H>(reader: Reader<H>, handle: H, bits: number): bigint | undefined {
   if (!Number.isInteger(bits) || bits < 0 || bits > 64) throw new Error('Invalid natural bit bound');
   let rest = handle, value = 0n, count = 0, last = 0n;
   for (;;) {
     const node = reader.observe(rest).node;
     if (node.kind === 'leaf') return count === 0 || last === 1n ? value : undefined;
     if (count === bits || node.kind !== 'fork') return undefined;
     const bit = reader.observe(node.left).node;
     if (bit.kind === 'leaf') last = 0n;
     else if (bit.kind === 'stem' && reader.observe(bit.child).node.kind === 'leaf') last = 1n;
     else return undefined;
     value |= last << BigInt(count++); rest = node.right;
   }
 }
 function name<H>(reader: Reader<H>, handle: H): string | undefined {
   let rest = handle, value = '';
   for (;;) {
     const node = reader.observe(rest).node;
     if (node.kind === 'leaf') return value || undefined;
     // Observe only the excess spine cell, never its head or tail.
     if (value.length === 64 || node.kind !== 'fork') return undefined;
     const code = canonicalNat(reader, node.left, 7);
     if (code === undefined || !(code >= 97n && code <= 122n || value.length > 0 && (code >= 48n && code <= 57n || code === 45n))) return undefined;
     value += String.fromCharCode(Number(code)); rest = node.right;
   }
 }
 export class ProtocolError extends Error {}
 export function decodeAction<H>(reader: Reader<H>, handle: H): Action<H> {
   const action = reader.observe(handle).node;
   if (action.kind !== 'fork') throw new ProtocolError('invalid computation shape');
   const code = canonicalNat(reader, action.left, 8);
   if (code !== undefined && code <= 9n) return { kind: 'core', code: Number(code), payload: action.right };
   if (code !== 10n) throw new ProtocolError('unknown computation constructor');
   const group = reader.observe(action.right).node;
   if (group.kind !== 'fork') throw new ProtocolError('invalid facility header');
   const revision = reader.observe(group.right).node;
   if (revision.kind !== 'fork') throw new ProtocolError('invalid facility header');
   const operation = reader.observe(revision.right).node;
   if (operation.kind !== 'fork') throw new ProtocolError('invalid facility header');
   const g = name(reader, group.left);
   if (g === undefined) throw new ProtocolError('invalid facility header');
   const v = canonicalNat(reader, revision.left, 16);
   if (v === undefined || v === 0n) throw new ProtocolError('invalid facility header');
   const op = name(reader, operation.left);
   if (op === undefined) throw new ProtocolError('invalid facility header');
   return { kind: 'request', group: g, revision: Number(v), operation: op, arguments: operation.right };
 }
 export function header<H>(reader: Reader<H>, handle: H): object {
   const action = decodeAction(reader, handle);
   return action.kind === 'core' ? { kind: action.kind, code: action.code }
     : { kind: action.kind, group: action.group, revision: action.revision, operation: action.operation };
 }