@statewalker/webrun-biscuit 0.1.0 → 0.2.0

package/src/datalog.ts

@@ -699,6 +699,16 @@ export class World {
     }
   }
 
+  /** every distinct fact `rule` derives from the facts `trusted` can see */
+  query(rule: Rule, trusted: TrustedOrigins): Predicate[] {
+    const seen = new Map<string, Predicate>();
+    for (const [, fact] of this.apply(rule, this.visible(trusted), AUTHORIZER)) {
+      const key = factKey(fact);
+      if (!seen.has(key)) seen.set(key, fact.predicate);
+    }
+    return [...seen.values()];
+  }
+
   /** `check if` / policies: does at least one combination match? */
   queryMatch(rule: Rule, origin: number, trusted: TrustedOrigins): boolean {
     for (const _ of this.apply(rule, this.visible(trusted), origin)) return true;

package/src/index.ts

@@ -11,8 +11,11 @@ import {
   type AuthorizationResult,
   type AuthorizeOptions,
   authorize,
+  type Evaluation,
+  evaluate,
   type LoadedToken,
   loadToken,
+  loadTokenAsync,
 } from "./authorizer.js";
 import { fromBase64, toBase64 } from "./base64.js";
 import {
@@ -31,8 +34,14 @@ export * from "./authorizer.js";
 export * from "./base64.js";
 export * from "./builder.js";
 export { SignatureError } from "./crypto.js";
-export { ExecutionError, type ExternFn, type Term } from "./datalog.js";
-export { ParseError } from "./parser.js";
+export {
+  ExecutionError,
+  type ExternFn,
+  type Predicate,
+  type RunLimits,
+  type Term,
+} from "./datalog.js";
+export { type ParamValue, type Params, ParseError } from "./parser.js";
 export { ProtoError } from "./proto.js";
 export * from "./version.js";
 
@@ -70,6 +79,17 @@ export class Biscuit {
   verify(rootPublicKey: Uint8Array, rootAlgorithm: 0 | 1 = 0): VerifiedBiscuit {
     return new VerifiedBiscuit(loadToken(this.bytes, rootPublicKey, rootAlgorithm), this.bytes);
   }
+
+  /**
+   * `verify`, using WebCrypto Ed25519 where the platform has it — roughly ten
+   * times faster than the pure-JS path. Rejects exactly where `verify` throws.
+   */
+  async verifyAsync(rootPublicKey: Uint8Array, rootAlgorithm: 0 | 1 = 0): Promise<VerifiedBiscuit> {
+    return new VerifiedBiscuit(
+      await loadTokenAsync(this.bytes, rootPublicKey, rootAlgorithm),
+      this.bytes,
+    );
+  }
 }
 
 /** A token whose signature chain has been checked against a root key. */
@@ -88,6 +108,10 @@ export class VerifiedBiscuit {
   authorize(authorizerCode: string, options?: AuthorizeOptions): AuthorizationResult {
     return authorize(this.token, authorizerCode, options);
   }
+  /** Authorize, keeping the evaluated world available to `query`. */
+  evaluate(authorizerCode: string, options?: AuthorizeOptions): Evaluation {
+    return evaluate(this.token, authorizerCode, options);
+  }
 }
 
 export { generateKeypair, thirdPartyBlock };

package/src/parser.ts

@@ -20,6 +20,55 @@ import {
 
 export class ParseError extends Error {}
 
+/**
+ * A value bound to a `{name}` parameter. It becomes a TERM, never source text,
+ * so no string can change the shape of the program it is bound into.
+ */
+export type ParamValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | null
+  | Date
+  | Uint8Array
+  | readonly ParamValue[]
+  | ReadonlySet<ParamValue>;
+
+export type Params = Readonly<Record<string, ParamValue>>;
+
+const I64_MIN = -(2n ** 63n);
+const I64_MAX = 2n ** 63n - 1n;
+
+function paramTerm(name: string, value: ParamValue): Term {
+  if (typeof value === "string") return { t: "str", v: value };
+  if (typeof value === "boolean") return { t: "bool", v: value };
+  if (value === null) return { t: "null" };
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value))
+      throw new ParseError(`parameter {${name}}: ${value} is not a safe integer`);
+    return { t: "int", v: BigInt(value) };
+  }
+  if (typeof value === "bigint") {
+    if (value < I64_MIN || value > I64_MAX)
+      throw new ParseError(`parameter {${name}}: ${value} does not fit in i64`);
+    return { t: "int", v: value };
+  }
+  if (value instanceof Date) {
+    const ms = value.getTime();
+    if (Number.isNaN(ms)) throw new ParseError(`parameter {${name}}: invalid date`);
+    return { t: "date", v: BigInt(Math.floor(ms / 1000)) };
+  }
+  if (value instanceof Uint8Array) return { t: "bytes", v: value };
+  if (Array.isArray(value)) return { t: "array", v: value.map((x) => paramTerm(name, x)) };
+  if (value instanceof Set)
+    return { t: "set", v: normalizeSet([...value].map((x) => paramTerm(name, x))) };
+  throw new ParseError(`parameter {${name}}: no Datalog term for this value`);
+}
+
+/** `{name}` in term position; `{true}`, `{false}` and `{null}` stay one-element sets */
+const PARAMETER = /^\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}/;
+
 export type Statement =
   | { k: "fact"; fact: Fact }
   | { k: "rule"; rule: Rule }
@@ -33,13 +82,20 @@ const NAME_CHAR = /[\p{L}\p{N}_:]/u;
 export class Parser {
   private i = 0;
   private readonly vars: Map<string, number>;
+  private readonly usedParams = new Set<string>();
   constructor(
     private readonly src: string,
     vars?: Map<string, number>,
+    private readonly params: Params = {},
   ) {
     this.vars = vars ?? new Map();
   }
 
+  /** names in `params` that the source never referred to */
+  unusedParameters(): string[] {
+    return Object.keys(this.params).filter((name) => !this.usedParams.has(name));
+  }
+
   /** id -> name, for printing rules back out */
   variableNames(): Map<number, string> {
     const out = new Map<number, string>();
@@ -188,7 +244,7 @@ export class Parser {
       return { t: "bytes", v: bytes };
     }
     if (this.peek("[")) return this.array(allowVariables);
-    if (this.peek("{")) return this.setOrMap(allowVariables);
+    if (this.peek("{")) return this.parameter() ?? this.setOrMap(allowVariables);
 
     const m = /^-?\d+/.exec(this.src.slice(this.i));
     if (m) {
@@ -200,6 +256,16 @@ export class Parser {
     );
   }
 
+  private parameter(): Term | null {
+    const m = PARAMETER.exec(this.src.slice(this.i));
+    if (!m || m[1] === "true" || m[1] === "false" || m[1] === "null") return null;
+    const name = m[1];
+    if (!Object.hasOwn(this.params, name)) throw new ParseError(`unbound parameter {${name}}`);
+    this.i += m[0].length;
+    this.usedParams.add(name);
+    return paramTerm(name, this.params[name]);
+  }
+
   private array(allowVariables: boolean): Term {
     this.expect("[");
     const items: Term[] = [];
@@ -603,4 +669,5 @@ export class Parser {
   }
 }
 
-export const parse = (src: string): Statement[] => new Parser(src).parse();
+export const parse = (src: string, params?: Params): Statement[] =>
+  new Parser(src, undefined, params).parse();

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022-2026 statewalker
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.