capdag 1.361.331 → 1.363.10

package/capdag.js

@@ -646,38 +646,38 @@ class CapUrn {
   }
 
   /**
-   * Check if this cap (pattern/handler) accepts a request (instance).
+   * Whether `cap` fits this cap read as a PATTERN over caps — what a search
+   * asks: `cap`'s input is within this pattern's, its output covers the
+   * pattern's, its effect is the pattern's (a pattern's `?effect` fits any),
+   * and its cap-tags — complete: a cap has the tags it has — satisfy the
+   * pattern's.
    *
-   * Direction (in/out) uses TaggedUrn.accepts()/conformsTo() (via MediaUrn matching):
-   * - Input: capIn.accepts(requestIn) — cap's input spec is pattern, request's input is instance
-   * - Output: capOut.conformsTo(requestOut) — cap's output is instance, request's output is pattern
-   * For other tags:
-   * - For each tag in the request: cap has same value, wildcard (*), or missing tag
-   * - For each tag in the cap: if request is missing that tag, that's fine (cap is more specific)
-   * Missing tags (except in/out) are treated as wildcards (less specific, can handle any value).
+   * A side the pattern leaves open is not asked about. `cap:candle` fits every
+   * cap tagged `candle`, whatever it takes and gives: its open output is "not
+   * established", not the type "anything".
    *
-   * @param {CapUrn} request - The request cap to check
-   * @returns {boolean} Whether this cap accepts the request
+   * Decided by the proved model (CapDAG.Exec.accepts, which is CapDAG.fits).
+   * For a question no cap URN can spell — "what gives this, whatever it
+   * takes" — ask a CapQuery.
+   *
+   * @param {CapUrn} cap - The cap to test against this pattern
+   * @returns {boolean} Whether the cap fits
    */
-  accepts(request) {
-    if (!request) {
+  accepts(cap) {
+    if (!cap) {
       return true;
     }
-    // Decided by the proved model (CapDAG.Exec.accepts). The cap-tag axis runs
-    // opposite to isDispatchable's: this is the pattern relation, dispatch is
-    // the routing one.
-    return model.accepts(this.formal, request.formal);
+    return model.accepts(this.formal, cap.formal);
   }
 
   /**
-   * Check if this cap (instance) conforms to another cap (pattern).
-   * Equivalent to cap.accepts(this).
+   * Whether this cap fits `pattern`: `pattern.accepts(this)`.
    *
-   * @param {CapUrn} cap - The cap to check conformance against
-   * @returns {boolean} Whether this cap conforms to the given cap
+   * @param {CapUrn} pattern
+   * @returns {boolean}
    */
-  conformsTo(cap) {
-    return cap.accepts(this);
+  conformsTo(pattern) {
+    return pattern.accepts(this);
   }
 
   /**
@@ -861,21 +861,64 @@ class CapUrn {
   }
 
   /**
-   * Check if this candidate can dispatch the given request.
+   * Whether this candidate SERVES `request` — the predicate routing and
+   * dispatch act on.
+   *
+   * The candidate takes at least what the request sends, gives at least what
+   * the request needs, has the effect asked for unless the request says
+   * `?effect`, and has the cap-tags asked for — its own tags being complete, so
+   * a request for `!x` is served by a candidate that does not mention `x`, and
+   * a candidate may carry tags the request does not ask about.
+   *
+   * An input the request leaves open is not established: the caller has not
+   * said what it will send, and every candidate passes that side. That is
+   * "some input", not "any input" — `media:` on a CANDIDATE's input does mean
+   * it takes anything.
+   *
+   * This is a guarantee. What only could serve does not; see mayDispatch and
+   * CapQuery.grade. Decided by the proved model (CapDAG.Exec.dispatch, which is
+   * CapDAG.serves). Not symmetric.
    *
    * @param {CapUrn} request
    * @returns {boolean}
    */
   isDispatchable(request) {
-    // Decided by the proved model (CapDAG.Exec.dispatch): every axis is a type.
-    // The request's input refines the candidate's, the candidate's output
-    // refines the request's, the effect matches unless the request says
-    // ?effect, and the candidate's cap-tags refine the request's. `media:` on
-    // a request's input is a type — "may send anything" — so only a candidate
-    // that accepts anything serves it, which is what makes dispatch compose.
     return model.dispatch(this.formal, request.formal);
   }
 
+  /**
+   * Whether this candidate COULD serve `request`: not guaranteed, not
+   * excluded. For exploring what the fabric might do — never for routing a
+   * call, which must be served.
+   *
+   * @param {CapUrn} request
+   * @returns {boolean}
+   */
+  mayDispatch(request) {
+    return model.mayDispatch(this.formal, request.formal);
+  }
+
+  /**
+   * Whether what this cap gives, `next` takes: the edge of a route.
+   *
+   * @param {CapUrn} next
+   * @returns {boolean}
+   */
+  flowsInto(next) {
+    return model.flows(this.formal, next.formal);
+  }
+
+  /**
+   * Whether what this cap gives COULD be something `next` takes: an edge a
+   * search may explore and a run has to check.
+   *
+   * @param {CapUrn} next
+   * @returns {boolean}
+   */
+  mayFlowInto(next) {
+    return model.mayFlow(this.formal, next.formal);
+  }
+
   /**
    * Infer the runtime output media for a concrete runtime input.
    *
@@ -886,7 +929,9 @@ class CapUrn {
     const declaredIn = this.inMediaUrn();
     const declaredOut = this.outMediaUrn();
 
-    if (!runtimeInput.conformsTo(declaredIn)) {
+    // A runtime media URN is the media of a value that exists, so it is read
+    // complete: it SATISFIES the declared type, or does not.
+    if (!runtimeInput.satisfies(declaredIn)) {
       throw new CapUrnError(
         ErrorCodes.INVALID_EFFECT_APPLICATION,
         `Runtime input '${runtimeInput}' does not conform to declared input '${declaredIn}'`
@@ -918,7 +963,7 @@ class CapUrn {
         );
     }
 
-    if (!runtimeOut.conformsTo(declaredOut)) {
+    if (!runtimeOut.satisfies(declaredOut)) {
       throw new CapUrnError(
         ErrorCodes.INVALID_EFFECT_APPLICATION,
         `Inferred runtime output '${runtimeOut}' does not conform to declared output '${declaredOut}'`
@@ -962,7 +1007,7 @@ class CapUrn {
       case CapEffect.PATCH:
         return runtimeOutput.isEquivalent(inferred);
       case CapEffect.DECLARED:
-        return runtimeOutput.conformsTo(inferred);
+        return runtimeOutput.satisfies(inferred);
       default:
         throw new CapUrnError(
           ErrorCodes.INVALID_EFFECT_APPLICATION,
@@ -1106,6 +1151,109 @@ class CapUrnBuilder {
   }
 }
 
+/**
+ * How a registered cap answers a CapQuery.
+ *
+ * - EXACT: guaranteed, and exactly what was asked on every side that was asked.
+ * - GUARANTEED: whatever the cap takes and gives, it is what was asked.
+ * - POSSIBLE: not guaranteed and not excluded — only running it tells. For
+ *   exploring; a call is never routed on it.
+ * - NONE: excluded.
+ */
+const MatchGrade = Object.freeze({
+  EXACT: 'exact',
+  GUARANTEED: 'guaranteed',
+  POSSIBLE: 'possible',
+  NONE: 'none',
+});
+
+/** Whether routing may act on a grade. */
+function gradeIsGuaranteed(grade) {
+  return grade === MatchGrade.EXACT || grade === MatchGrade.GUARANTEED;
+}
+
+/** The cap-tag pattern a query asks for: `cap:` with these tags (none asks for none). */
+function queryTagPattern(tags) {
+  return modelUrn(new TaggedUrn('cap', { ...(tags || {}) }));
+}
+
+/**
+ * A question about caps.
+ *
+ * A request is not a cap. A cap takes this and gives that; a request is a
+ * QUESTION about caps, and may leave a side unasked: "what gives me this file,
+ * whatever it takes?", "what can this input become?". Those are not cap URNs
+ * with `media:` on a side — `media:` is the type "anything", a claim about
+ * every input — they are queries with that side unknown.
+ *
+ * A cap URN read as a request or as a pattern is one (fromRequest, fromPattern)
+ * — which is what CapUrn.isDispatchable and CapUrn.accepts ask — and so are the
+ * questions no cap URN can spell (producing, consuming, between). Every answer
+ * is decided by the proved model (formal/CapDAG/Query.lean).
+ */
+class CapQuery {
+  constructor(formal, asked) {
+    Object.defineProperty(this, 'formal', { value: formal, enumerable: false });
+    this.asked = asked;
+    Object.freeze(this);
+  }
+
+  toString() {
+    return this.asked;
+  }
+
+  /** The cap URN `request`, read as a request: an input it leaves open is not established. */
+  static fromRequest(request) {
+    return new CapQuery(model.queryOfRequest(request.formal), `request ${request}`);
+  }
+
+  /** The cap URN `pattern`, read as a pattern over caps: an output it leaves open is not established. */
+  static fromPattern(pattern) {
+    return new CapQuery(model.queryOfPattern(pattern.formal), `pattern ${pattern}`);
+  }
+
+  /** Caps that GIVE `output`, whatever they take, with the cap-tags `tags` asks for. */
+  static producing(output, tags) {
+    return new CapQuery(
+      model.queryProducing(modelUrn(output._urn), queryTagPattern(tags)),
+      `anything giving ${output}`);
+  }
+
+  /** Caps that TAKE `input`, whatever they give: what this input can become in one step. */
+  static consuming(input, tags) {
+    return new CapQuery(
+      model.queryConsuming(modelUrn(input._urn), queryTagPattern(tags)),
+      `anything taking ${input}`);
+  }
+
+  /** Caps that take `input` and give `output`: nothing unknown. */
+  static between(input, output, tags) {
+    return new CapQuery(
+      model.queryBetween(modelUrn(input._urn), modelUrn(output._urn), queryTagPattern(tags)),
+      `anything taking ${input} and giving ${output}`);
+  }
+
+  /** Whether `cap` is guaranteed to be what is asked. */
+  admits(cap) {
+    return model.queryAdmits(this.formal, cap.formal);
+  }
+
+  /** Whether `cap` could be what is asked. */
+  mayAdmit(cap) {
+    return model.queryMayAdmit(this.formal, cap.formal);
+  }
+
+  /** How `cap` answers: one of MatchGrade. */
+  grade(cap) {
+    const answer = model.queryGrade(this.formal, cap.formal);
+    const grade = { exact: MatchGrade.EXACT, guaranteed: MatchGrade.GUARANTEED, possible: MatchGrade.POSSIBLE, none: MatchGrade.NONE }[answer.kind];
+    if (grade === undefined) {
+      throw new Error(`capdag: the model answered with a grade this mirror does not know: ${JSON.stringify(answer)}`);
+    }
+    return grade;
+  }
+}
+
 /**
  * Cap Matcher utility class
  */
@@ -1615,6 +1763,34 @@ class MediaUrn {
    */
   accepts(instance) { return this._urn.accepts(instance._urn); }
 
+  /**
+   * Whether this media type and `other` COULD describe the same value: not a
+   * guarantee (conformsTo), and not excluded. `media:ext` meets
+   * `media:ext=pdf`; `media:ext=pdf` does not meet `media:ext=png`.
+   * @param {MediaUrn} other
+   * @returns {boolean}
+   */
+  meets(other) { return this._urn.meets(other._urn); }
+
+  /**
+   * Whether a VALUE whose media this is satisfies the type `pattern`.
+   *
+   * conformsTo compares two types, and a type that does not mention a key
+   * says nothing about it. A value that exists is complete: the tags it does
+   * not have, it does not have. Use this where the receiver is the media of
+   * actual data — a stream that arrived, an output that was produced.
+   * @param {MediaUrn} pattern
+   * @returns {boolean}
+   */
+  satisfies(pattern) { return this._urn.satisfies(pattern._urn); }
+
+  /**
+   * Whether a value whose media this is COULD satisfy `pattern`.
+   * @param {MediaUrn} pattern
+   * @returns {boolean}
+   */
+  maySatisfy(pattern) { return this._urn.maySatisfy(pattern._urn); }
+
   /** @returns {number} Specificity score (tag count based) */
   specificity() { return this._urn.specificity(); }
 
@@ -2720,13 +2896,14 @@ class Cap {
   }
 
   /**
-   * Check if this capability accepts a request string
+   * Whether this capability, as a candidate, can serve the request
+   * (CapUrn.isDispatchable).
    * @param {string} request - The request string
-   * @returns {boolean} Whether this capability accepts the request
+   * @returns {boolean} Whether this capability serves the request
    */
   acceptsRequest(request) {
     const requestUrn = CapUrn.fromString(request);
-    return this.urn.accepts(requestUrn);
+    return this.urn.isDispatchable(requestUrn);
   }
 
   /**
@@ -5343,16 +5520,17 @@ class CartridgeRepoServer {
   }
 
   /**
-   * Get cartridges that provide a specific cap.
+   * Get every cartridge with a cap that can SERVE the requested URN.
    *
-   * The request URN is parsed via CapUrn.fromString. Each declared
-   * cartridge cap is parsed and matched with `conformsTo`: cap dispatch
-   * is the partial-order question "does the declared cap conform to
-   * (i.e. refine, equal, or be more specific than) the requested
-   * pattern?". Only `in` and `out` tags are semantically meaningful —
-   * no string comparison, no special role for the `op` tag. A malformed
-   * input URN throws; a malformed declared URN in the registry also
-   * throws (registry corruption is not a fallback condition).
+   * The request URN is parsed via CapUrn.fromString; each declared
+   * cartridge cap is parsed too and asked `isDispatchable` — "can this
+   * declared candidate serve the request?" (it takes at least what is
+   * sent, gives at least what is needed, has the tags asked for; a side the
+   * request leaves open is not asked about). This is deliberately looser
+   * than the equivalence used to resolve an alias to its exact cap: here
+   * everything capable is enumerated. A malformed input URN throws; a
+   * malformed declared URN in the registry also throws (registry corruption
+   * is not a fallback condition).
    */
   getCartridgesByCap(capUrn) {
     const requested = CapUrn.fromString(capUrn);
@@ -5361,7 +5539,7 @@ class CartridgeRepoServer {
       (p.cap_groups || []).some(g =>
         (g.caps || []).some(c => {
           const declared = CapUrn.fromString(c.urn);
-          return declared.conformsTo(requested);
+          return declared.isDispatchable(requested);
         })
       )
     );
@@ -8438,6 +8616,9 @@ export {
   CapEffect,
   CapUrnBuilder,
   CapMatcher,
+  CapQuery,
+  MatchGrade,
+  gradeIsGuaranteed,
   CapUrnError,
   ErrorCodes,
   MediaUrn,

package/formal/index.d.ts

@@ -19,6 +19,30 @@ export type Effect =
 ;
 export function effectType(): L.Type<Effect>;
 
+/** Lean's CapDAG.Exec.WfQuery. */
+export interface WfQuery {
+  readonly input: WfAsk;
+  readonly output: WfAsk;
+  readonly tags: Wf;
+  readonly effect: Effect;
+}
+export function wfQueryType(): L.Type<WfQuery>;
+
+/** Lean's TaggedUrn.Exec.Wf, held by handle: only the program's functions make and read its values. */
+export class Wf extends L.Opaque {
+  private constructor();
+}
+export function wfType(): L.Type<Wf>;
+
+/** Lean's CapDAG.Grade. */
+export type Grade =
+  | { readonly kind: "exact" }
+  | { readonly kind: "guaranteed" }
+  | { readonly kind: "possible" }
+  | { readonly kind: "none" }
+;
+export function gradeType(): L.Type<Grade>;
+
 /** Lean's TaggedUrn.Constraint. */
 export type Constraint =
   | { readonly kind: "missing" }
@@ -31,11 +55,14 @@ export type Constraint =
 ;
 export function constraintType(): L.Type<Constraint>;
 
-/** Lean's TaggedUrn.Exec.Wf, held by handle: only the program's functions make and read its values. */
-export class Wf extends L.Opaque {
-  private constructor();
-}
-export function wfType(): L.Type<Wf>;
+/** Lean's CapDAG.Exec.WfAsk. */
+export type WfAsk =
+  | { readonly kind: "unknown" }
+  | { readonly kind: "within"; readonly u: Wf }
+  | { readonly kind: "covers"; readonly u: Wf }
+  | { readonly kind: "same"; readonly u: Wf }
+;
+export function wfAskType(): L.Type<WfAsk>;
 
 /** The layout fingerprint and descriptor of each type, by Lean name, for modules using them. */
 export const leanTypes: {
@@ -46,7 +73,7 @@ export const leanTypes: {
 export class CapdagFormal {
   private constructor();
   /** Lean's CapDAG.Exec.accepts : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
-  accepts(pattern: WfCap, request: WfCap): boolean;
+  accepts(pattern: WfCap, cap: WfCap): boolean;
   /** Lean's CapDAG.Exec.comparable : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
   comparable(a: WfCap, b: WfCap): boolean;
   /** Lean's CapDAG.Exec.dispatch : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
@@ -55,6 +82,28 @@ export class CapdagFormal {
   effectOk(candidate: Effect, request: Effect): boolean;
   /** Lean's CapDAG.Exec.equivalent : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
   equivalent(a: WfCap, b: WfCap): boolean;
+  /** Lean's CapDAG.Exec.flows : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
+  flows(a: WfCap, b: WfCap): boolean;
+  /** Lean's CapDAG.Exec.mayDispatch : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
+  mayDispatch(candidate: WfCap, request: WfCap): boolean;
+  /** Lean's CapDAG.Exec.mayFlow : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Bool */
+  mayFlow(a: WfCap, b: WfCap): boolean;
+  /** Lean's CapDAG.Exec.queryAdmits : CapDAG.Exec.WfQuery → CapDAG.Exec.WfCap → Bool */
+  queryAdmits(q: WfQuery, c: WfCap): boolean;
+  /** Lean's CapDAG.Exec.queryBetween : TaggedUrn.Exec.Wf → TaggedUrn.Exec.Wf → TaggedUrn.Exec.Wf → CapDAG.Exec.WfQuery */
+  queryBetween(input: Wf, output: Wf, tags: Wf): WfQuery;
+  /** Lean's CapDAG.Exec.queryConsuming : TaggedUrn.Exec.Wf → TaggedUrn.Exec.Wf → CapDAG.Exec.WfQuery */
+  queryConsuming(input: Wf, tags: Wf): WfQuery;
+  /** Lean's CapDAG.Exec.queryGrade : CapDAG.Exec.WfQuery → CapDAG.Exec.WfCap → CapDAG.Grade */
+  queryGrade(q: WfQuery, c: WfCap): Grade;
+  /** Lean's CapDAG.Exec.queryMayAdmit : CapDAG.Exec.WfQuery → CapDAG.Exec.WfCap → Bool */
+  queryMayAdmit(q: WfQuery, c: WfCap): boolean;
+  /** Lean's CapDAG.Exec.queryOfPattern : CapDAG.Exec.WfCap → CapDAG.Exec.WfQuery */
+  queryOfPattern(p: WfCap): WfQuery;
+  /** Lean's CapDAG.Exec.queryOfRequest : CapDAG.Exec.WfCap → CapDAG.Exec.WfQuery */
+  queryOfRequest(r_: WfCap): WfQuery;
+  /** Lean's CapDAG.Exec.queryProducing : TaggedUrn.Exec.Wf → TaggedUrn.Exec.Wf → CapDAG.Exec.WfQuery */
+  queryProducing(output: Wf, tags: Wf): WfQuery;
   /** Lean's CapDAG.Exec.rankingKey : CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Nat × Nat */
   rankingKey(candidate: WfCap, request: WfCap): [bigint, bigint];
   /** Lean's CapDAG.Exec.select : List CapDAG.Exec.WfCap → CapDAG.Exec.WfCap → Option CapDAG.Exec.WfCap */

package/formal/index.js

@@ -68,10 +68,81 @@ export function effectType() {
   );
 }
 
+/** Describes CapDAG.Exec.WfQuery for polymorphic functions. */
+export function wfQueryType() {
+  return new L.Type(
+    L.inductiveExpr(2),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfQuery");
+      w.u32(0);
+      wfAskType().encode(w, v.input);
+      wfAskType().encode(w, v.output);
+      wfType().encode(w, v.tags);
+      effectType().encode(w, v.effect);
+    },
+    (r) => {
+      const c = r.u32();
+      if (c !== 0) throw new L.MalformedError(`constructor index ${c} of CapDAG.Exec.WfQuery`);
+      return ({ input: wfAskType().decode(r), output: wfAskType().decode(r), tags: wfType().decode(r), effect: effectType().decode(r) });
+    },
+  );
+}
+
+/** Lean's TaggedUrn.Exec.Wf, held by handle: only the program's functions make and read its values. */
+export class Wf extends L.Opaque {}
+
+/** Describes TaggedUrn.Exec.Wf for polymorphic functions. */
+export function wfType() {
+  return new L.Type(
+    L.inductiveExpr(3),
+    (w, v) => {
+      if (!(v instanceof Wf)) throw new L.MalformedError("not a TaggedUrn.Exec.Wf");
+      L.OPAQUE.encode(w, v);
+    },
+    (r) => new Wf(r.program, r.u64()),
+  );
+}
+
+/** Describes CapDAG.Grade for polymorphic functions. */
+export function gradeType() {
+  return new L.Type(
+    L.inductiveExpr(4),
+    (w, v) => {
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Grade");
+      switch (v.kind) {
+        case "exact":
+          w.u32(0);
+          return;
+        case "guaranteed":
+          w.u32(1);
+          return;
+        case "possible":
+          w.u32(2);
+          return;
+        case "none":
+          w.u32(3);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Grade`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "exact" });
+        case 1: return ({ kind: "guaranteed" });
+        case 2: return ({ kind: "possible" });
+        case 3: return ({ kind: "none" });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Grade`);
+      }
+    },
+  );
+}
+
 /** Describes TaggedUrn.Constraint for polymorphic functions. */
 export function constraintType() {
   return new L.Type(
-    L.inductiveExpr(2),
+    L.inductiveExpr(5),
     (w, v) => {
       if (typeof v !== "object" || v === null) throw new L.MalformedError("not a TaggedUrn.Constraint");
       switch (v.kind) {
@@ -119,18 +190,42 @@ export function constraintType() {
   );
 }
 
-/** Lean's TaggedUrn.Exec.Wf, held by handle: only the program's functions make and read its values. */
-export class Wf extends L.Opaque {}
-
-/** Describes TaggedUrn.Exec.Wf for polymorphic functions. */
-export function wfType() {
+/** Describes CapDAG.Exec.WfAsk for polymorphic functions. */
+export function wfAskType() {
   return new L.Type(
-    L.inductiveExpr(3),
+    L.inductiveExpr(6),
     (w, v) => {
-      if (!(v instanceof Wf)) throw new L.MalformedError("not a TaggedUrn.Exec.Wf");
-      L.OPAQUE.encode(w, v);
+      if (typeof v !== "object" || v === null) throw new L.MalformedError("not a CapDAG.Exec.WfAsk");
+      switch (v.kind) {
+        case "unknown":
+          w.u32(0);
+          return;
+        case "within":
+          w.u32(1);
+          wfType().encode(w, v.u);
+          return;
+        case "covers":
+          w.u32(2);
+          wfType().encode(w, v.u);
+          return;
+        case "same":
+          w.u32(3);
+          wfType().encode(w, v.u);
+          return;
+        default:
+          throw new L.MalformedError(`${String(v.kind)} is not a constructor of CapDAG.Exec.WfAsk`);
+      }
+    },
+    (r) => {
+      const c = r.u32();
+      switch (c) {
+        case 0: return ({ kind: "unknown" });
+        case 1: return ({ kind: "within", u: wfType().decode(r) });
+        case 2: return ({ kind: "covers", u: wfType().decode(r) });
+        case 3: return ({ kind: "same", u: wfType().decode(r) });
+        default: throw new L.MalformedError(`constructor index ${c} of CapDAG.Exec.WfAsk`);
+      }
     },
-    (r) => new Wf(r.program, r.u64()),
   );
 }
 
@@ -138,8 +233,11 @@ export function wfType() {
 export const leanTypes = Object.freeze({
   "CapDAG.Exec.WfCap": Object.freeze({ fingerprint: "2b8d6466d218f4ae6bc98d95bba55d98f21cac4a49446ae170993773cefdb830", type: wfCapType }),
   "CapDAG.Effect": Object.freeze({ fingerprint: "38c7bd3c0527cda156713cd441c9b6b92bd5df8a39108fa101449a789abcb477", type: effectType }),
-  "TaggedUrn.Constraint": Object.freeze({ fingerprint: "481fc09e23c6415a7c3f05887577ec940a6ecc84b005e63476c1060b59edcac7", type: constraintType }),
+  "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.Exec.WfAsk": Object.freeze({ fingerprint: "d286477c7abc4e6bc6ee2d06889372b71a5bb06605b592ebabb6ad3eaf71b952", type: wfAskType }),
 });
 
 /** The Lean program capdagFormal. */
@@ -148,8 +246,8 @@ export class CapdagFormal {
   constructor(program) {
     this.#program = program;
   }
-  accepts(pattern, request) {
-    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_daccepts", [], [[wfCapType(), pattern], [wfCapType(), request]], L.value(L.BOOL));
+  accepts(pattern, cap) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_daccepts", [], [[wfCapType(), pattern], [wfCapType(), cap]], L.value(L.BOOL));
   }
   comparable(a, b) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dcomparable", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
@@ -163,6 +261,39 @@ export class CapdagFormal {
   equivalent(a, b) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dequivalent", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
   }
+  flows(a, b) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dflows", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
+  }
+  mayDispatch(candidate, request) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dmayDispatch", [], [[wfCapType(), candidate], [wfCapType(), request]], L.value(L.BOOL));
+  }
+  mayFlow(a, b) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dmayFlow", [], [[wfCapType(), a], [wfCapType(), b]], L.value(L.BOOL));
+  }
+  queryAdmits(q, c) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryAdmits", [], [[wfQueryType(), q], [wfCapType(), c]], L.value(L.BOOL));
+  }
+  queryBetween(input, output, tags) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryBetween", [], [[wfType(), input], [wfType(), output], [wfType(), tags]], L.value(wfQueryType()));
+  }
+  queryConsuming(input, tags) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryConsuming", [], [[wfType(), input], [wfType(), tags]], L.value(wfQueryType()));
+  }
+  queryGrade(q, c) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryGrade", [], [[wfQueryType(), q], [wfCapType(), c]], L.value(gradeType()));
+  }
+  queryMayAdmit(q, c) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryMayAdmit", [], [[wfQueryType(), q], [wfCapType(), c]], L.value(L.BOOL));
+  }
+  queryOfPattern(p) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryOfPattern", [], [[wfCapType(), p]], L.value(wfQueryType()));
+  }
+  queryOfRequest(r_) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryOfRequest", [], [[wfCapType(), r_]], L.value(wfQueryType()));
+  }
+  queryProducing(output, tags) {
+    return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_dqueryProducing", [], [[wfType(), output], [wfType(), tags]], L.value(wfQueryType()));
+  }
   rankingKey(candidate, request) {
     return this.#program.invoke("capdagFormal__call_l_CapDAG_dExec_drankingKey", [], [[wfCapType(), candidate], [wfCapType(), request]], L.value(L.pair(L.NAT, L.NAT)));
   }

package/package.json

@@ -3,7 +3,7 @@
   "dependencies": {
     "lungo-ts": "1.78.3254",
     "peggy": "^5.1.0",
-    "tagged-urn": "^1.66.108"
+    "tagged-urn": "^1.68.11"
   },
   "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.361.331"
+  "version": "1.363.10"
 }