capdag 1.363.10 → 1.368.19

package/README.md

@@ -17,7 +17,7 @@ npm install capdag
 
 The package is an ES module and needs Node.js 20 or newer. Dispatch,
 acceptance, equivalence and specificity are decided by code generated from the
-proved model ([formal foundations](https://capdag.com/docs/02-formal-foundations/)),
+proved model ([formal foundations](https://machinefabric.com/capdag/docs/02-formal-foundations/)),
 which runs as WebAssembly: it is instantiated when the package is first
 imported, so importing it waits for that (top-level `await`), and a CommonJS
 `require` cannot load it.
@@ -53,7 +53,7 @@ equivalence, conformance, dispatch, and ranking instead of string surgery.
 - [`RULES.md`](RULES.md) records package-specific construction rules.
 
 The normative semantics and terminology live in the
-[CapDAG specification](https://capdag.com/docs/01-overview/). Source comments and
+[CapDAG specification](https://machinefabric.com/capdag/docs/01-overview/). Source comments and
 exports are the JavaScript API reference.
 
 ## Use it in a browser

package/formal/index.d.ts

@@ -1,6 +1,163 @@
-// Generated by lungo 1.78.3254 from Lean 4.34.1 for program capdagFormal. Do not edit.
+// Generated by lungo 1.82.64 from Lean 4.34.1 for program capdagFormal. Do not edit.
 import * as L from "lungo-ts";
 
+/** Lean's CapDAG.Bifaci.Credit.Gate. */
+export interface Gate {
+  readonly available: bigint;
+  readonly closed: L.Option<string>;
+}
+export function gateType(): L.Type<Gate>;
+
+/** Lean's CapDAG.Bifaci.Credit.Acquire. */
+export type Acquire =
+  | { readonly kind: "acquired"; readonly gate: Gate }
+  | { readonly kind: "wait" }
+  | { readonly kind: "closed"; readonly reason: string }
+;
+export function acquireType(): L.Type<Acquire>;
+
+/** Lean's CapDAG.Bifaci.Credit.Window. */
+export interface Window {
+  readonly remaining: bigint;
+  readonly pending: bigint;
+  readonly batch: bigint;
+}
+export function windowType(): L.Type<Window>;
+
+/** Lean's CapDAG.Bifaci.Credit.Arrival. */
+export type CreditArrival =
+  | { readonly kind: "accepted"; readonly window: Window }
+  | { readonly kind: "violation" }
+;
+export function creditArrivalType(): L.Type<CreditArrival>;
+
+/** Lean's CapDAG.Bifaci.Credit.Granted. */
+export interface Granted {
+  readonly window: Window;
+  readonly grant: bigint;
+}
+export function grantedType(): L.Type<Granted>;
+
+/** Lean's CapDAG.Bifaci.Flow.FrameType. */
+export type FrameType =
+  | { readonly kind: "hello" }
+  | { readonly kind: "req" }
+  | { readonly kind: "chunk" }
+  | { readonly kind: "fin" }
+  | { readonly kind: "log" }
+  | { readonly kind: "err" }
+  | { readonly kind: "heartbeat" }
+  | { readonly kind: "streamStart" }
+  | { readonly kind: "streamEnd" }
+  | { readonly kind: "relayNotify" }
+  | { readonly kind: "relayState" }
+  | { readonly kind: "cancel" }
+  | { readonly kind: "credit" }
+  | { readonly kind: "closeStream" }
+;
+export function frameTypeType(): L.Type<FrameType>;
+
+/** Lean's CapDAG.Bifaci.Flow.Reorder. */
+export interface Reorder {
+  readonly expected: bigint;
+  readonly held: Array<bigint>;
+}
+export function reorderType(): L.Type<Reorder>;
+
+/** Lean's CapDAG.Bifaci.Flow.Accepted. */
+export type Accepted =
+  | { readonly kind: "deliver"; readonly flow: Reorder; readonly seqs: Array<bigint> }
+  | { readonly kind: "hold"; readonly flow: Reorder }
+  | { readonly kind: "stale" }
+  | { readonly kind: "duplicate" }
+  | { readonly kind: "overflow" }
+;
+export function acceptedType(): L.Type<Accepted>;
+
+/** Lean's CapDAG.Bifaci.Pools.State. */
+export interface State {
+  readonly pools: Array<Pool>;
+  readonly queue: Array<Waiter>;
+  readonly next: bigint;
+}
+export function stateType(): L.Type<State>;
+
+/** Lean's CapDAG.Bifaci.Pools.Waiter. */
+export interface Waiter {
+  readonly ticket: bigint;
+  readonly chain: Array<string>;
+}
+export function waiterType(): L.Type<Waiter>;
+
+/** Lean's CapDAG.Bifaci.Pools.Arrival. */
+export type PoolsArrival =
+  | { readonly kind: "admitted"; readonly state: State }
+  | { readonly kind: "queued"; readonly state: State; readonly ticket: bigint; readonly position: bigint }
+  | { readonly kind: "unknownPool"; readonly name: string }
+;
+export function poolsArrivalType(): L.Type<PoolsArrival>;
+
+/** Lean's CapDAG.Bifaci.Pools.Patience. */
+export type Patience =
+  | { readonly kind: "unbounded" }
+  | { readonly kind: "atMost"; readonly remaining: bigint }
+  | { readonly kind: "exhausted" }
+;
+export function patienceType(): L.Type<Patience>;
+
+/** Lean's CapDAG.Bifaci.Request.Phase. */
+export type Phase =
+  | { readonly kind: "created" }
+  | { readonly kind: "streaming" }
+;
+export function phaseType(): L.Type<Phase>;
+
+/** Lean's CapDAG.Bifaci.Request.Emitted. */
+export type Emitted =
+  | { readonly kind: "streamStart"; readonly stream: string }
+  | { readonly kind: "chunk"; readonly stream: string; readonly index: bigint }
+  | { readonly kind: "streamEnd"; readonly stream: string; readonly count: L.Option<bigint> }
+  | { readonly kind: "fin" }
+  | { readonly kind: "err" }
+  | { readonly kind: "other" }
+;
+export function emittedType(): L.Type<Emitted>;
+
+/** Lean's CapDAG.Bifaci.Request.Violation. */
+export type Violation =
+  | { readonly kind: "afterEnd" }
+  | { readonly kind: "streamRestarted"; readonly stream: string }
+  | { readonly kind: "streamNotOpen"; readonly stream: string }
+  | { readonly kind: "chunkOutOfPlace"; readonly stream: string; readonly expected: bigint; readonly got: bigint }
+  | { readonly kind: "chunkCountWrong"; readonly stream: string; readonly sent: bigint; readonly said: bigint }
+  | { readonly kind: "endWithOpenStream"; readonly stream: string }
+;
+export function violationType(): L.Type<Violation>;
+
+/** Lean's CapDAG.Bifaci.Request.Disposition. */
+export type Disposition =
+  | { readonly kind: "route" }
+  | { readonly kind: "straggler" }
+  | { readonly kind: "noRoute" }
+;
+export function dispositionType(): L.Type<Disposition>;
+
+/** Lean's CapDAG.Bifaci.Request.Terminal. */
+export type Terminal =
+  | { readonly kind: "finished" }
+  | { readonly kind: "failed" }
+  | { readonly kind: "cancelled" }
+  | { readonly kind: "masterDied" }
+;
+export function terminalType(): L.Type<Terminal>;
+
+/** Lean's CapDAG.Bifaci.Request.Write. */
+export type Write =
+  | { readonly kind: "send"; readonly ends: boolean }
+  | { readonly kind: "suppress" }
+;
+export function writeType(): L.Type<Write>;
+
 /** Lean's CapDAG.Exec.WfCap. */
 export interface WfCap {
   readonly input: Wf;
@@ -55,6 +212,14 @@ export type Constraint =
 ;
 export function constraintType(): L.Type<Constraint>;
 
+/** Lean's CapDAG.Bifaci.Pools.Pool. */
+export interface Pool {
+  readonly name: string;
+  readonly capacity: bigint;
+  readonly active: bigint;
+}
+export function poolType(): L.Type<Pool>;
+
 /** Lean's CapDAG.Exec.WfAsk. */
 export type WfAsk =
   | { readonly kind: "unknown" }
@@ -72,6 +237,82 @@ export const leanTypes: {
 /** The Lean program capdagFormal. */
 export class CapdagFormal {
   private constructor();
+  /** Lean's CapDAG.Bifaci.Credit.Gate.acquire : CapDAG.Bifaci.Credit.Gate → Nat → CapDAG.Bifaci.Credit.Acquire */
+  acquire(g: Gate, n: bigint): Acquire;
+  /** Lean's CapDAG.Bifaci.Credit.Gate.close : CapDAG.Bifaci.Credit.Gate → String → CapDAG.Bifaci.Credit.Gate */
+  close(g: Gate, reason: string): Gate;
+  /** Lean's CapDAG.Bifaci.Credit.Gate.grant : CapDAG.Bifaci.Credit.Gate → Nat → CapDAG.Bifaci.Credit.Gate */
+  grant(g: Gate, n: bigint): Gate;
+  /** Lean's CapDAG.Bifaci.Credit.Gate.opened : Nat → CapDAG.Bifaci.Credit.Gate */
+  gateOpened(window: bigint): Gate;
+  /** Lean's CapDAG.Bifaci.Credit.Window.arrive : CapDAG.Bifaci.Credit.Window → CapDAG.Bifaci.Credit.Arrival */
+  windowArrive(w_: Window): CreditArrival;
+  /** Lean's CapDAG.Bifaci.Credit.Window.consume : CapDAG.Bifaci.Credit.Window → CapDAG.Bifaci.Credit.Granted */
+  consume(w_: Window): Granted;
+  /** Lean's CapDAG.Bifaci.Credit.Window.continued : CapDAG.Bifaci.Credit.Window → CapDAG.Bifaci.Credit.Granted */
+  continued(w_: Window): Granted;
+  /** Lean's CapDAG.Bifaci.Credit.Window.flush : CapDAG.Bifaci.Credit.Window → CapDAG.Bifaci.Credit.Granted */
+  flush(w_: Window): Granted;
+  /** Lean's CapDAG.Bifaci.Credit.Window.opened : Nat → CapDAG.Bifaci.Credit.Window */
+  windowOpened(window: bigint): Window;
+  /** Lean's CapDAG.Bifaci.Credit.grantTarget : List (Option String) → Option String → Option (Option String) */
+  grantTarget(streams: Array<L.Option<string>>, named: L.Option<string>): L.Option<L.Option<string>>;
+  /** Lean's CapDAG.Bifaci.Credit.negotiate : Nat → Nat → Option Nat */
+  negotiate(ours: bigint, theirs: bigint): L.Option<bigint>;
+  /** Lean's CapDAG.Bifaci.Flow.FrameType.code : CapDAG.Bifaci.Flow.FrameType → Nat */
+  code(a: FrameType): bigint;
+  /** Lean's CapDAG.Bifaci.Flow.FrameType.isFlow : CapDAG.Bifaci.Flow.FrameType → Bool */
+  isFlow(a: FrameType): boolean;
+  /** Lean's CapDAG.Bifaci.Flow.FrameType.isTerminal : CapDAG.Bifaci.Flow.FrameType → Bool */
+  isTerminal(a: FrameType): boolean;
+  /** Lean's CapDAG.Bifaci.Flow.FrameType.ofCode : Nat → Option CapDAG.Bifaci.Flow.FrameType */
+  ofCode(a: bigint): L.Option<FrameType>;
+  /** Lean's CapDAG.Bifaci.Flow.Reorder.accept : CapDAG.Bifaci.Flow.Reorder → Nat → Nat → CapDAG.Bifaci.Flow.Accepted */
+  accept(r_: Reorder, seq: bigint, limit: bigint): Accepted;
+  /** Lean's CapDAG.Bifaci.Flow.Reorder.start : CapDAG.Bifaci.Flow.Reorder */
+  start(): Reorder;
+  /** Lean's CapDAG.Bifaci.Pools.State.admit : CapDAG.Bifaci.Pools.State → Nat → Option CapDAG.Bifaci.Pools.State */
+  admit(s: State, ticket: bigint): L.Option<State>;
+  /** Lean's CapDAG.Bifaci.Pools.State.admitNext : CapDAG.Bifaci.Pools.State → Option (CapDAG.Bifaci.Pools.Waiter × CapDAG.Bifaci.Pools.State) */
+  admitNext(s: State): L.Option<[Waiter, State]>;
+  /** Lean's CapDAG.Bifaci.Pools.State.arrive : CapDAG.Bifaci.Pools.State → List String → CapDAG.Bifaci.Pools.Arrival */
+  stateArrive(s: State, chain: Array<string>): PoolsArrival;
+  /** Lean's CapDAG.Bifaci.Pools.State.empty : CapDAG.Bifaci.Pools.State */
+  empty(): State;
+  /** Lean's CapDAG.Bifaci.Pools.State.hasRoom : CapDAG.Bifaci.Pools.State → List String → Bool */
+  hasRoom(s: State, chain: Array<string>): boolean;
+  /** Lean's CapDAG.Bifaci.Pools.State.heldBack : CapDAG.Bifaci.Pools.State → String → Nat */
+  heldBack(s: State, name: string): bigint;
+  /** Lean's CapDAG.Bifaci.Pools.State.join : CapDAG.Bifaci.Pools.State → List String → CapDAG.Bifaci.Pools.Arrival */
+  join(s: State, chain: Array<string>): PoolsArrival;
+  /** Lean's CapDAG.Bifaci.Pools.State.leave : CapDAG.Bifaci.Pools.State → Nat → CapDAG.Bifaci.Pools.State */
+  leave(s: State, ticket: bigint): State;
+  /** Lean's CapDAG.Bifaci.Pools.State.position : CapDAG.Bifaci.Pools.State → Nat → Nat */
+  position(s: State, ticket: bigint): bigint;
+  /** Lean's CapDAG.Bifaci.Pools.State.release : CapDAG.Bifaci.Pools.State → List String → CapDAG.Bifaci.Pools.State */
+  release(s: State, chain: Array<string>): State;
+  /** Lean's CapDAG.Bifaci.Pools.State.setCapacity : CapDAG.Bifaci.Pools.State → String → Nat → CapDAG.Bifaci.Pools.State */
+  setCapacity(s: State, name: string, capacity: bigint): State;
+  /** Lean's CapDAG.Bifaci.Pools.advertised : Bool → String → Nat → Option Nat → Nat */
+  advertised(running: boolean, pool: string, configured: bigint, available: L.Option<bigint>): bigint;
+  /** Lean's CapDAG.Bifaci.Pools.chain : String → List (String × List String) → List String */
+  chain(cap: string, shared: Array<[string, Array<string>]>): Array<string>;
+  /** Lean's CapDAG.Bifaci.Pools.effective : Nat → Option Nat → Nat */
+  effective(configured: bigint, available: L.Option<bigint>): bigint;
+  /** Lean's CapDAG.Bifaci.Pools.patience : Option Nat → Nat → CapDAG.Bifaci.Pools.Patience */
+  patience(unavailableFor: L.Option<bigint>, grace: bigint): Patience;
+  /** Lean's CapDAG.Bifaci.Request.Phase.after : CapDAG.Bifaci.Request.Phase → CapDAG.Bifaci.Flow.FrameType → CapDAG.Bifaci.Request.Phase */
+  after(p: Phase, frame: FrameType): Phase;
+  /** Lean's CapDAG.Bifaci.Request.check : List CapDAG.Bifaci.Request.Emitted → Option CapDAG.Bifaci.Request.Violation */
+  check(frames: Array<Emitted>): L.Option<Violation>;
+  /** Lean's CapDAG.Bifaci.Request.dispose : Bool → Bool → CapDAG.Bifaci.Request.Disposition */
+  dispose(live: boolean, endedLately: boolean): Disposition;
+  /** Lean's CapDAG.Bifaci.Request.ledger : Int → CapDAG.Bifaci.Flow.FrameType → Nat → Int */
+  ledger(remaining: bigint, frame: FrameType, granted: bigint): bigint;
+  /** Lean's CapDAG.Bifaci.Request.terminalOf : CapDAG.Bifaci.Flow.FrameType → Option CapDAG.Bifaci.Request.Terminal */
+  terminalOf(a: FrameType): L.Option<Terminal>;
+  /** Lean's CapDAG.Bifaci.Request.write : Bool → CapDAG.Bifaci.Flow.FrameType → CapDAG.Bifaci.Request.Write */
+  write(over: boolean, frame: FrameType): Write;
   /** Lean's CapDAG.Exec.accepts : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
   accepts(pattern: WfCap, cap: WfCap): boolean;
   /** Lean's CapDAG.Exec.comparable : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */

package/formal/index.js

@@ -1,4 +1,4 @@
-// Generated by lungo 1.78.3254 from Lean 4.34.1 for program capdagFormal. Do not edit.
+// Generated by lungo 1.82.64 from Lean 4.34.1 for program capdagFormal. Do not edit.
 import * as L from "lungo-ts";
 
 async function programModule() {
@@ -12,10 +12,599 @@ async function programModule() {
   return response.arrayBuffer();
 }
 
+/** Describes CapDAG.Bifaci.Credit.Gate for polymorphic functions. */
+export function gateType() {
+  return new L.Type(
+    L.inductiveExpr(0),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Gate");
+      w.u32(0);
+      L.NAT.encode(w, v.available);
+      L.option(L.STRING).encode(w, v.closed);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Gate`);
+      return ({ available: L.NAT.decode(r), closed: L.option(L.STRING).decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Acquire for polymorphic functions. */
+export function acquireType() {
+  return new L.Type(
+    L.inductiveExpr(1),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Acquire");
+      switch (v.kind) {
+        case "acquired":
+          w.u32(0);
+          gateType().encode(w, v.gate);
+          return;
+        case "wait":
+          w.u32(1);
+          return;
+        case "closed":
+          w.u32(2);
+          L.STRING.encode(w, v.reason);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Credit.Acquire`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "acquired", gate: gateType().decode(r) });
+        case 1: return ({ kind: "wait" });
+        case 2: return ({ kind: "closed", reason: L.STRING.decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Acquire`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Window for polymorphic functions. */
+export function windowType() {
+  return new L.Type(
+    L.inductiveExpr(2),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Window");
+      w.u32(0);
+      L.NAT.encode(w, v.remaining);
+      L.NAT.encode(w, v.pending);
+      L.NAT.encode(w, v.batch);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Window`);
+      return ({ remaining: L.NAT.decode(r), pending: L.NAT.decode(r), batch: L.NAT.decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Arrival for polymorphic functions. */
+export function creditArrivalType() {
+  return new L.Type(
+    L.inductiveExpr(3),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Arrival");
+      switch (v.kind) {
+        case "accepted":
+          w.u32(0);
+          windowType().encode(w, v.window);
+          return;
+        case "violation":
+          w.u32(1);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Credit.Arrival`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "accepted", window: windowType().decode(r) });
+        case 1: return ({ kind: "violation" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Arrival`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Credit.Granted for polymorphic functions. */
+export function grantedType() {
+  return new L.Type(
+    L.inductiveExpr(4),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Credit.Granted");
+      w.u32(0);
+      windowType().encode(w, v.window);
+      L.NAT.encode(w, v.grant);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Credit.Granted`);
+      return ({ window: windowType().decode(r), grant: L.NAT.decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Flow.FrameType for polymorphic functions. */
+export function frameTypeType() {
+  return new L.Type(
+    L.inductiveExpr(5),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Flow.FrameType");
+      switch (v.kind) {
+        case "hello":
+          w.u32(0);
+          return;
+        case "req":
+          w.u32(1);
+          return;
+        case "chunk":
+          w.u32(2);
+          return;
+        case "fin":
+          w.u32(3);
+          return;
+        case "log":
+          w.u32(4);
+          return;
+        case "err":
+          w.u32(5);
+          return;
+        case "heartbeat":
+          w.u32(6);
+          return;
+        case "streamStart":
+          w.u32(7);
+          return;
+        case "streamEnd":
+          w.u32(8);
+          return;
+        case "relayNotify":
+          w.u32(9);
+          return;
+        case "relayState":
+          w.u32(10);
+          return;
+        case "cancel":
+          w.u32(11);
+          return;
+        case "credit":
+          w.u32(12);
+          return;
+        case "closeStream":
+          w.u32(13);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Flow.FrameType`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "hello" });
+        case 1: return ({ kind: "req" });
+        case 2: return ({ kind: "chunk" });
+        case 3: return ({ kind: "fin" });
+        case 4: return ({ kind: "log" });
+        case 5: return ({ kind: "err" });
+        case 6: return ({ kind: "heartbeat" });
+        case 7: return ({ kind: "streamStart" });
+        case 8: return ({ kind: "streamEnd" });
+        case 9: return ({ kind: "relayNotify" });
+        case 10: return ({ kind: "relayState" });
+        case 11: return ({ kind: "cancel" });
+        case 12: return ({ kind: "credit" });
+        case 13: return ({ kind: "closeStream" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Flow.FrameType`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Flow.Reorder for polymorphic functions. */
+export function reorderType() {
+  return new L.Type(
+    L.inductiveExpr(6),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Flow.Reorder");
+      w.u32(0);
+      L.NAT.encode(w, v.expected);
+      L.list(L.NAT).encode(w, v.held);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Flow.Reorder`);
+      return ({ expected: L.NAT.decode(r), held: L.list(L.NAT).decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Flow.Accepted for polymorphic functions. */
+export function acceptedType() {
+  return new L.Type(
+    L.inductiveExpr(7),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Flow.Accepted");
+      switch (v.kind) {
+        case "deliver":
+          w.u32(0);
+          reorderType().encode(w, v.flow);
+          L.list(L.NAT).encode(w, v.seqs);
+          return;
+        case "hold":
+          w.u32(1);
+          reorderType().encode(w, v.flow);
+          return;
+        case "stale":
+          w.u32(2);
+          return;
+        case "duplicate":
+          w.u32(3);
+          return;
+        case "overflow":
+          w.u32(4);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Flow.Accepted`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "deliver", flow: reorderType().decode(r), seqs: L.list(L.NAT).decode(r) });
+        case 1: return ({ kind: "hold", flow: reorderType().decode(r) });
+        case 2: return ({ kind: "stale" });
+        case 3: return ({ kind: "duplicate" });
+        case 4: return ({ kind: "overflow" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Flow.Accepted`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.State for polymorphic functions. */
+export function stateType() {
+  return new L.Type(
+    L.inductiveExpr(8),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.State");
+      w.u32(0);
+      L.list(poolType()).encode(w, v.pools);
+      L.list(waiterType()).encode(w, v.queue);
+      L.NAT.encode(w, v.next);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.State`);
+      return ({ pools: L.list(poolType()).decode(r), queue: L.list(waiterType()).decode(r), next: L.NAT.decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.Waiter for polymorphic functions. */
+export function waiterType() {
+  return new L.Type(
+    L.inductiveExpr(9),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Waiter");
+      w.u32(0);
+      L.NAT.encode(w, v.ticket);
+      L.list(L.STRING).encode(w, v.chain);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Waiter`);
+      return ({ ticket: L.NAT.decode(r), chain: L.list(L.STRING).decode(r) });
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.Arrival for polymorphic functions. */
+export function poolsArrivalType() {
+  return new L.Type(
+    L.inductiveExpr(10),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Arrival");
+      switch (v.kind) {
+        case "admitted":
+          w.u32(0);
+          stateType().encode(w, v.state);
+          return;
+        case "queued":
+          w.u32(1);
+          stateType().encode(w, v.state);
+          L.NAT.encode(w, v.ticket);
+          L.NAT.encode(w, v.position);
+          return;
+        case "unknownPool":
+          w.u32(2);
+          L.STRING.encode(w, v.name);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Pools.Arrival`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "admitted", state: stateType().decode(r) });
+        case 1: return ({ kind: "queued", state: stateType().decode(r), ticket: L.NAT.decode(r), position: L.NAT.decode(r) });
+        case 2: return ({ kind: "unknownPool", name: L.STRING.decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Arrival`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Pools.Patience for polymorphic functions. */
+export function patienceType() {
+  return new L.Type(
+    L.inductiveExpr(11),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Patience");
+      switch (v.kind) {
+        case "unbounded":
+          w.u32(0);
+          return;
+        case "atMost":
+          w.u32(1);
+          L.NAT.encode(w, v.remaining);
+          return;
+        case "exhausted":
+          w.u32(2);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Pools.Patience`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "unbounded" });
+        case 1: return ({ kind: "atMost", remaining: L.NAT.decode(r) });
+        case 2: return ({ kind: "exhausted" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Patience`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Phase for polymorphic functions. */
+export function phaseType() {
+  return new L.Type(
+    L.inductiveExpr(12),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Phase");
+      switch (v.kind) {
+        case "created":
+          w.u32(0);
+          return;
+        case "streaming":
+          w.u32(1);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Phase`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "created" });
+        case 1: return ({ kind: "streaming" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Phase`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Emitted for polymorphic functions. */
+export function emittedType() {
+  return new L.Type(
+    L.inductiveExpr(13),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Emitted");
+      switch (v.kind) {
+        case "streamStart":
+          w.u32(0);
+          L.STRING.encode(w, v.stream);
+          return;
+        case "chunk":
+          w.u32(1);
+          L.STRING.encode(w, v.stream);
+          L.NAT.encode(w, v.index);
+          return;
+        case "streamEnd":
+          w.u32(2);
+          L.STRING.encode(w, v.stream);
+          L.option(L.NAT).encode(w, v.count);
+          return;
+        case "fin":
+          w.u32(3);
+          return;
+        case "err":
+          w.u32(4);
+          return;
+        case "other":
+          w.u32(5);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Emitted`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "streamStart", stream: L.STRING.decode(r) });
+        case 1: return ({ kind: "chunk", stream: L.STRING.decode(r), index: L.NAT.decode(r) });
+        case 2: return ({ kind: "streamEnd", stream: L.STRING.decode(r), count: L.option(L.NAT).decode(r) });
+        case 3: return ({ kind: "fin" });
+        case 4: return ({ kind: "err" });
+        case 5: return ({ kind: "other" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Emitted`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Violation for polymorphic functions. */
+export function violationType() {
+  return new L.Type(
+    L.inductiveExpr(14),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Violation");
+      switch (v.kind) {
+        case "afterEnd":
+          w.u32(0);
+          return;
+        case "streamRestarted":
+          w.u32(1);
+          L.STRING.encode(w, v.stream);
+          return;
+        case "streamNotOpen":
+          w.u32(2);
+          L.STRING.encode(w, v.stream);
+          return;
+        case "chunkOutOfPlace":
+          w.u32(3);
+          L.STRING.encode(w, v.stream);
+          L.NAT.encode(w, v.expected);
+          L.NAT.encode(w, v.got);
+          return;
+        case "chunkCountWrong":
+          w.u32(4);
+          L.STRING.encode(w, v.stream);
+          L.NAT.encode(w, v.sent);
+          L.NAT.encode(w, v.said);
+          return;
+        case "endWithOpenStream":
+          w.u32(5);
+          L.STRING.encode(w, v.stream);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Violation`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "afterEnd" });
+        case 1: return ({ kind: "streamRestarted", stream: L.STRING.decode(r) });
+        case 2: return ({ kind: "streamNotOpen", stream: L.STRING.decode(r) });
+        case 3: return ({ kind: "chunkOutOfPlace", stream: L.STRING.decode(r), expected: L.NAT.decode(r), got: L.NAT.decode(r) });
+        case 4: return ({ kind: "chunkCountWrong", stream: L.STRING.decode(r), sent: L.NAT.decode(r), said: L.NAT.decode(r) });
+        case 5: return ({ kind: "endWithOpenStream", stream: L.STRING.decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Violation`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Disposition for polymorphic functions. */
+export function dispositionType() {
+  return new L.Type(
+    L.inductiveExpr(15),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Disposition");
+      switch (v.kind) {
+        case "route":
+          w.u32(0);
+          return;
+        case "straggler":
+          w.u32(1);
+          return;
+        case "noRoute":
+          w.u32(2);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Disposition`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "route" });
+        case 1: return ({ kind: "straggler" });
+        case 2: return ({ kind: "noRoute" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Disposition`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Terminal for polymorphic functions. */
+export function terminalType() {
+  return new L.Type(
+    L.inductiveExpr(16),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Terminal");
+      switch (v.kind) {
+        case "finished":
+          w.u32(0);
+          return;
+        case "failed":
+          w.u32(1);
+          return;
+        case "cancelled":
+          w.u32(2);
+          return;
+        case "masterDied":
+          w.u32(3);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Terminal`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "finished" });
+        case 1: return ({ kind: "failed" });
+        case 2: return ({ kind: "cancelled" });
+        case 3: return ({ kind: "masterDied" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Terminal`);
+      }
+    },
+  );
+}
+
+/** Describes CapDAG.Bifaci.Request.Write for polymorphic functions. */
+export function writeType() {
+  return new L.Type(
+    L.inductiveExpr(17),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Request.Write");
+      switch (v.kind) {
+        case "send":
+          w.u32(0);
+          L.BOOL.encode(w, v.ends);
+          return;
+        case "suppress":
+          w.u32(1);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Bifaci.Request.Write`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "send", ends: L.BOOL.decode(r) });
+        case 1: return ({ kind: "suppress" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Request.Write`);
+      }
+    },
+  );
+}
+
 /** Describes CapDAG.Exec.WfCap for polymorphic functions. */
 export function wfCapType() {
   return new L.Type(
-    L.inductiveExpr(0),
+    L.inductiveExpr(18),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfCap");
       w.u32(0);
@@ -35,7 +624,7 @@ export function wfCapType() {
 /** Describes CapDAG.Effect for polymorphic functions. */
 export function effectType() {
   return new L.Type(
-    L.inductiveExpr(1),
+    L.inductiveExpr(19),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Effect");
       switch (v.kind) {
@@ -71,7 +660,7 @@ export function effectType() {
 /** Describes CapDAG.Exec.WfQuery for polymorphic functions. */
 export function wfQueryType() {
   return new L.Type(
-    L.inductiveExpr(2),
+    L.inductiveExpr(20),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfQuery");
       w.u32(0);
@@ -94,7 +683,7 @@ export class Wf extends L.Opaque {}
 /** Describes TaggedUrn.Exec.Wf for polymorphic functions. */
 export function wfType() {
   return new L.Type(
-    L.inductiveExpr(3),
+    L.inductiveExpr(21),
     (w, v) => {
       if (!(v instanceof Wf)) throw new L.MalformedError("not a TaggedUrn.Exec.Wf");
       L.OPAQUE.encode(w, v);
@@ -106,7 +695,7 @@ export function wfType() {
 /** Describes CapDAG.Grade for polymorphic functions. */
 export function gradeType() {
   return new L.Type(
-    L.inductiveExpr(4),
+    L.inductiveExpr(22),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Grade");
       switch (v.kind) {
@@ -142,7 +731,7 @@ export function gradeType() {
 /** Describes TaggedUrn.Constraint for polymorphic functions. */
 export function constraintType() {
   return new L.Type(
-    L.inductiveExpr(5),
+    L.inductiveExpr(23),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a TaggedUrn.Constraint");
       switch (v.kind) {
@@ -190,10 +779,29 @@ export function constraintType() {
   );
 }
 
+/** Describes CapDAG.Bifaci.Pools.Pool for polymorphic functions. */
+export function poolType() {
+  return new L.Type(
+    L.inductiveExpr(24),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Bifaci.Pools.Pool");
+      w.u32(0);
+      L.STRING.encode(w, v.name);
+      L.NAT.encode(w, v.capacity);
+      L.NAT.encode(w, v.active);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Bifaci.Pools.Pool`);
+      return ({ name: L.STRING.decode(r), capacity: L.NAT.decode(r), active: L.NAT.decode(r) });
+    },
+  );
+}
+
 /** Describes CapDAG.Exec.WfAsk for polymorphic functions. */
 export function wfAskType() {
   return new L.Type(
-    L.inductiveExpr(6),
+    L.inductiveExpr(25),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfAsk");
       switch (v.kind) {
@@ -231,12 +839,31 @@ export function wfAskType() {
 
 /** The layout fingerprint and descriptor of each type, by Lean name, for modules using them. */
 export const leanTypes = Object.freeze({
+  "CapDAG.Bifaci.Credit.Gate": Object.freeze({ fingerprint: "b10dc9a4cff1977f4f6a2c415147f497f98740255d0158fb2b3a2a99d4d1b135", type: gateType }),
+  "CapDAG.Bifaci.Credit.Acquire": Object.freeze({ fingerprint: "0dabbf62c4dad8c3f81811acc80f5c789d25191897bb2621de51b5f94e54a4c9", type: acquireType }),
+  "CapDAG.Bifaci.Credit.Window": Object.freeze({ fingerprint: "28df89763b22214ef57dfd7f1a3c0da786ff78af9768fe453cd451870749b6fe", type: windowType }),
+  "CapDAG.Bifaci.Credit.Arrival": Object.freeze({ fingerprint: "940f01cf50eb8b763b9f44cc84753fcdbc65fbc0f816ab279408e74208649797", type: creditArrivalType }),
+  "CapDAG.Bifaci.Credit.Granted": Object.freeze({ fingerprint: "47f8d3e63e9aaf7c4b602f781afce57fc832e3d4d645c6adabd25c461abed233", type: grantedType }),
+  "CapDAG.Bifaci.Flow.FrameType": Object.freeze({ fingerprint: "3d6742b864aeb68cf6add586acfcd1a9663a3816d718f8d8aadc3c5e3dab3e2f", type: frameTypeType }),
+  "CapDAG.Bifaci.Flow.Reorder": Object.freeze({ fingerprint: "d1e8b655f24db5e8b2348d6d41084a5c454346eb0a81fcf11b671432e72291bf", type: reorderType }),
+  "CapDAG.Bifaci.Flow.Accepted": Object.freeze({ fingerprint: "a821d7a044f52a71dfd932fff60d2f3560ce5197658283853a56fb54aa96b69b", type: acceptedType }),
+  "CapDAG.Bifaci.Pools.State": Object.freeze({ fingerprint: "20f7299c188d09234cda39e9cc356242e2b5bc56a09cf819d12d7f50fa24989b", type: stateType }),
+  "CapDAG.Bifaci.Pools.Waiter": Object.freeze({ fingerprint: "48d81c7e41df114e88751bb5c1f4a84c16bac3ad28d8eacba141d45f92c79da0", type: waiterType }),
+  "CapDAG.Bifaci.Pools.Arrival": Object.freeze({ fingerprint: "6bee196c56c330c4ef348f4dd5a68558b2d19105592969cc64a0e7150bd22451", type: poolsArrivalType }),
+  "CapDAG.Bifaci.Pools.Patience": Object.freeze({ fingerprint: "d32e3427e590ca6002e38cface52d020c7df74603f952bf568401f7291d5648c", type: patienceType }),
+  "CapDAG.Bifaci.Request.Phase": Object.freeze({ fingerprint: "7407437b58ce033618bf82341b13aaa9661d29a5a9b0f1bf1547ea0bfcfd8374", type: phaseType }),
+  "CapDAG.Bifaci.Request.Emitted": Object.freeze({ fingerprint: "97a274be14c5baecf9c50243d3651da838c5de4375366d4102cbcff85fb211c8", type: emittedType }),
+  "CapDAG.Bifaci.Request.Violation": Object.freeze({ fingerprint: "203fb2fc4f8ff3c79b70871b4274852e742adf97c3cc4e6631439ec66d838f09", type: violationType }),
+  "CapDAG.Bifaci.Request.Disposition": Object.freeze({ fingerprint: "540307dfb6e509ccde4b894c69566edd1f3f9c3223b9325e97ee91b20d0fb82f", type: dispositionType }),
+  "CapDAG.Bifaci.Request.Terminal": Object.freeze({ fingerprint: "3597c3196cef5e4468b5449eb0da09af414bb8c3aa40d92b027089f6ae81c870", type: terminalType }),
+  "CapDAG.Bifaci.Request.Write": Object.freeze({ fingerprint: "9ae21282903c8131c25ca1cc527e51fd1fa5137aa77c9ef4f3d091e9415a109a", type: writeType }),
   "CapDAG.Exec.WfCap": Object.freeze({ fingerprint: "2b8d6466d218f4ae6bc98d95bba55d98f21cac4a49446ae170993773cefdb830", type: wfCapType }),
   "CapDAG.Effect": Object.freeze({ fingerprint: "38c7bd3c0527cda156713cd441c9b6b92bd5df8a39108fa101449a789abcb477", type: effectType }),
   "CapDAG.Exec.WfQuery": Object.freeze({ fingerprint: "e734861d70e3177f6563c4492990bb65131f0450b8dfc62071eb61b6c5f08b8e", type: wfQueryType }),
   "TaggedUrn.Exec.Wf": Object.freeze({ fingerprint: "20e9f81ad195b2f4a481e7a5dcae2b3d0de6efe7b3dc720db0e2aa3b52527785", type: wfType }),
   "CapDAG.Grade": Object.freeze({ fingerprint: "0a2a20a14d9ecca6121343df2d8a7f2478b3e837710ed522ed385d35efdf46f2", type: gradeType }),
   "TaggedUrn.Constraint": Object.freeze({ fingerprint: "481fc09e23c6415a7c3f05887577ec940a6ecc84b005e63476c1060b59edcac7", type: constraintType }),
+  "CapDAG.Bifaci.Pools.Pool": Object.freeze({ fingerprint: "60bca9d670886c7830c76779ad692b4fbb6e4e30c0ce6b3e9d5a91a9b5b7b1e6", type: poolType }),
   "CapDAG.Exec.WfAsk": Object.freeze({ fingerprint: "d286477c7abc4e6bc6ee2d06889372b71a5bb06605b592ebabb6ad3eaf71b952", type: wfAskType }),
 });
 
@@ -246,6 +873,120 @@ export class CapdagFormal {
   constructor(program) {
     this.#program = program;
   }
+  acquire(g, n) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dacquire", [], [[gateType(), g], [L.NAT, n]], L.value(acquireType()));
+  }
+  close(g, reason) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dclose", [], [[gateType(), g], [L.STRING, reason]], L.value(gateType()));
+  }
+  grant(g, n) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dgrant", [], [[gateType(), g], [L.NAT, n]], L.value(gateType()));
+  }
+  gateOpened(window) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dGate_dopened", [], [[L.NAT, window]], L.value(gateType()));
+  }
+  windowArrive(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_darrive", [], [[windowType(), w_]], L.value(creditArrivalType()));
+  }
+  consume(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dconsume", [], [[windowType(), w_]], L.value(grantedType()));
+  }
+  continued(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dcontinued", [], [[windowType(), w_]], L.value(grantedType()));
+  }
+  flush(w_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dflush", [], [[windowType(), w_]], L.value(grantedType()));
+  }
+  windowOpened(window) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dWindow_dopened", [], [[L.NAT, window]], L.value(windowType()));
+  }
+  grantTarget(streams, named) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dgrantTarget", [], [[L.list(L.option(L.STRING)), streams], [L.option(L.STRING), named]], L.value(L.option(L.option(L.STRING))));
+  }
+  negotiate(ours, theirs) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dCredit_dnegotiate", [], [[L.NAT, ours], [L.NAT, theirs]], L.value(L.option(L.NAT)));
+  }
+  code(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_dcode", [], [[frameTypeType(), a]], L.value(L.NAT));
+  }
+  isFlow(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_disFlow", [], [[frameTypeType(), a]], L.value(L.BOOL));
+  }
+  isTerminal(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_disTerminal", [], [[frameTypeType(), a]], L.value(L.BOOL));
+  }
+  ofCode(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dFrameType_dofCode", [], [[L.NAT, a]], L.value(L.option(frameTypeType())));
+  }
+  accept(r_, seq, limit) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dReorder_daccept", [], [[reorderType(), r_], [L.NAT, seq], [L.NAT, limit]], L.value(acceptedType()));
+  }
+  start() {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dFlow_dReorder_dstart", [], [], L.value(reorderType()));
+  }
+  admit(s, ticket) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dadmit", [], [[stateType(), s], [L.NAT, ticket]], L.value(L.option(stateType())));
+  }
+  admitNext(s) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dadmitNext", [], [[stateType(), s]], L.value(L.option(L.pair(waiterType(), stateType()))));
+  }
+  stateArrive(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_darrive", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(poolsArrivalType()));
+  }
+  empty() {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dempty", [], [], L.value(stateType()));
+  }
+  hasRoom(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dhasRoom", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(L.BOOL));
+  }
+  heldBack(s, name) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dheldBack", [], [[stateType(), s], [L.STRING, name]], L.value(L.NAT));
+  }
+  join(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_djoin", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(poolsArrivalType()));
+  }
+  leave(s, ticket) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dleave", [], [[stateType(), s], [L.NAT, ticket]], L.value(stateType()));
+  }
+  position(s, ticket) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dposition", [], [[stateType(), s], [L.NAT, ticket]], L.value(L.NAT));
+  }
+  release(s, chain) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_drelease", [], [[stateType(), s], [L.list(L.STRING), chain]], L.value(stateType()));
+  }
+  setCapacity(s, name, capacity) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dState_dsetCapacity", [], [[stateType(), s], [L.STRING, name], [L.NAT, capacity]], L.value(stateType()));
+  }
+  advertised(running, pool, configured, available) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dadvertised", [], [[L.BOOL, running], [L.STRING, pool], [L.NAT, configured], [L.option(L.NAT), available]], L.value(L.NAT));
+  }
+  chain(cap, shared) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dchain", [], [[L.STRING, cap], [L.list(L.pair(L.STRING, L.list(L.STRING))), shared]], L.value(L.list(L.STRING)));
+  }
+  effective(configured, available) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_deffective", [], [[L.NAT, configured], [L.option(L.NAT), available]], L.value(L.NAT));
+  }
+  patience(unavailableFor, grace) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dPools_dpatience", [], [[L.option(L.NAT), unavailableFor], [L.NAT, grace]], L.value(patienceType()));
+  }
+  after(p, frame) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dPhase_dafter", [], [[phaseType(), p], [frameTypeType(), frame]], L.value(phaseType()));
+  }
+  check(frames) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dcheck", [], [[L.list(emittedType()), frames]], L.value(L.option(violationType())));
+  }
+  dispose(live, endedLately) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_ddispose", [], [[L.BOOL, live], [L.BOOL, endedLately]], L.value(dispositionType()));
+  }
+  ledger(remaining, frame, granted) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dledger", [], [[L.INT, remaining], [frameTypeType(), frame], [L.NAT, granted]], L.value(L.INT));
+  }
+  terminalOf(a) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dterminalOf", [], [[frameTypeType(), a]], L.value(L.option(terminalType())));
+  }
+  write(over, frame) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dBifaci_dRequest_dwrite", [], [[L.BOOL, over], [frameTypeType(), frame]], L.value(writeType()));
+  }
   accepts(pattern, cap) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_daccepts", [], [[wfCapType(), pattern], [wfCapType(), cap]], L.value(L.BOOL));
   }

package/package.json

@@ -1,9 +1,9 @@
 {
   "author": "Bahram Joharshamshiri",
   "dependencies": {
-    "lungo-ts": "1.78.3254",
+    "lungo-ts": "1.82.64",
     "peggy": "^5.1.0",
-    "tagged-urn": "^1.68.11"
+    "tagged-urn": "^1.71.14"
   },
   "description": "JavaScript implementation of Cap URN (Capability Uniform Resource Names) with strict validation and matching",
   "engines": {
@@ -50,5 +50,5 @@
     "test": "node capdag.test.js"
   },
   "type": "module",
-  "version": "1.363.10"
+  "version": "1.368.19"
 }