@diister/quick-permission 0.9.0-beta.5

package/indirect-aggregation.ts

@@ -0,0 +1,216 @@
+/**
+ * Orchestrateur : transforme une liste de grants + ressources indirectes
+ * déclarées en un pipeline d'aggregation MongoDB qui pushe les
+ * contraintes de jointure en DB.
+ *
+ * Algorithme :
+ *  1. Identifier les indirect resources réellement référencées par les
+ *     `with` keys des grants.
+ *  2. Transitivement pull les indirect resources parentes (chaînage).
+ *  3. Trier topologiquement (parent avant enfant) pour que les `$lookup`
+ *     enfants puissent référencer l'alias produit par leur parent.
+ *  4. Émettre un `$lookup` par indirect resource (dédup par `id`).
+ *  5. Émettre un `$match` final OR-isé cross-grant par indirect resource,
+ *     AND-é entre indirect resources distinctes.
+ */
+
+import type { Grant } from "./types.ts";
+import type { IndirectResource } from "./indirect-resource.ts";
+import { validateSpec } from "./mongo-query.ts";
+
+export type AggregationStage = Record<string, unknown>;
+export type MongoFilter = Record<string, unknown>;
+
+/**
+ * Construit le pipeline complet à partir du `baseFilter` (les contraintes
+ * find-style classiques agrégées par `aggregateConstraints`) et de la
+ * liste des grants matchés.
+ *
+ * Retourne :
+ *  - `null` quand aucune indirect resource ne contribue effectivement
+ *    de filtre — soit aucun grant ne les référence, soit la sémantique
+ *    "any wins" s'applique (au moins un grant ne référence pas
+ *    l'indirect → le set complet est admissible). Dans ce cas le
+ *    consommateur retombe sur le mode find classique avec `constraints`.
+ *  - Un array de stages sinon (mode aggregation pipeline).
+ *
+ * La sémantique "any wins" est essentielle pour la composition
+ * cross-grant : un admin global avec un grant "open" sur la même perm
+ * doit court-circuiter le filtre que d'autres grants tenteraient
+ * d'imposer via une indirect resource — exactement comme
+ * `aggregateConstraints` traite `undefined` comme "any wins" pour les
+ * constraints find-style.
+ */
+export function buildAggregationStages(
+  baseFilter: MongoFilter,
+  grants: readonly Grant[],
+  declaredIndirect: readonly IndirectResource[],
+): AggregationStage[] | null {
+  const indirectById = new Map<string, IndirectResource>();
+  for (const ir of declaredIndirect) indirectById.set(ir.id, ir);
+
+  // Indirects référencées par AU MOINS un grant.
+  const referenced = new Set<string>();
+  for (const g of grants) {
+    if (!g.with) continue;
+    for (const id of Object.keys(g.with)) {
+      if (indirectById.has(id)) referenced.add(id);
+    }
+  }
+
+  if (referenced.size === 0) return null;
+
+  // Sémantique "any wins" : une indirect ne contribue de filtre que si
+  // TOUS les grants matchés portent une condition pour elle. Sinon le
+  // grant sans condition ouvre la porte au set complet → on n'a pas le
+  // droit de filtrer sur cette indirect.
+  const effective = new Set<string>();
+  for (const id of referenced) {
+    if (grants.every((g) => g.with?.[id] !== undefined)) {
+      effective.add(id);
+    }
+  }
+
+  if (effective.size === 0) return null;
+
+  // Pull in chained parents (transitivement) pour les indirects effectives.
+  const required = new Set<string>(effective);
+  for (const id of effective) {
+    walkDeps(indirectById.get(id)!, required, indirectById);
+  }
+
+  // Topological order: parent before child.
+  const ordered = topoSort([...required].map((id) => indirectById.get(id)!));
+
+  const stages: AggregationStage[] = [{ $match: baseFilter }];
+  for (const ir of ordered) {
+    stages.push(buildLookupStage(ir));
+  }
+
+  // Per-indirect cross-grant OR; cross-indirect AND.
+  const matchClauses: MongoFilter[] = [];
+  for (const irId of effective) {
+    const ir = indirectById.get(irId)!;
+    const perGrantSpecs: MongoFilter[] = [];
+    for (const g of grants) {
+      const spec = g.with?.[irId] as MongoFilter | undefined;
+      if (!spec) continue;
+      // Security: same whitelist as `match` rule for direct resources —
+      // grants may come from untrusted providers, the spec ends up
+      // pushed to Mongo as-is. Reject dangerous operators ($where,
+      // $expr, $function, etc.) before they reach the DB.
+      validateSpec(spec);
+      perGrantSpecs.push(spec);
+    }
+    // `effective` guarantees all grants have a spec, so perGrantSpecs is
+    // non-empty here.
+
+    const path = lookupAlias(ir);
+    const elemMatches: MongoFilter[] = perGrantSpecs.map((spec) => ({
+      [path]: { $elemMatch: { ...staticTypeFilter(ir), ...spec } },
+    }));
+    matchClauses.push(
+      elemMatches.length === 1 ? elemMatches[0] : { $or: elemMatches },
+    );
+  }
+
+  if (matchClauses.length > 0) {
+    stages.push({
+      $match:
+        matchClauses.length === 1 ? matchClauses[0] : { $and: matchClauses },
+    });
+  }
+
+  return stages;
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────
+
+function walkDeps(
+  ir: IndirectResource,
+  acc: Set<string>,
+  byId: Map<string, IndirectResource>,
+): void {
+  if (ir.from.kind === "indirect") {
+    const parent = byId.get(ir.from.id);
+    if (parent && !acc.has(parent.id)) {
+      acc.add(parent.id);
+      walkDeps(parent, acc, byId);
+    }
+  }
+}
+
+function topoSort(items: IndirectResource[]): IndirectResource[] {
+  const sorted: IndirectResource[] = [];
+  const remaining = new Set(items.map((i) => i.id));
+  const byId = new Map(items.map((i) => [i.id, i] as const));
+
+  while (remaining.size > 0) {
+    let progressed = false;
+    for (const id of [...remaining]) {
+      const ir = byId.get(id)!;
+      const parentId = ir.from.kind === "indirect" ? ir.from.id : null;
+      const parentInSet = parentId !== null && remaining.has(parentId);
+      if (!parentInSet) {
+        sorted.push(ir);
+        remaining.delete(id);
+        progressed = true;
+      }
+    }
+    if (!progressed) {
+      throw new Error("Cycle detected in indirect resource chain");
+    }
+  }
+  return sorted;
+}
+
+function lookupAlias(ir: IndirectResource): string {
+  return `_${ir.id}`;
+}
+
+function staticTypeFilter(ir: IndirectResource): MongoFilter {
+  return ir.to?._type ? { _type: ir.to._type } : {};
+}
+
+function buildLookupStage(ir: IndirectResource): AggregationStage {
+  const isChained = ir.from.kind === "indirect";
+  // `<self>` est un placeholder neutre — le consommateur (mongodbee
+  // adapter) substitue le nom de la collection courante côté driver.
+  const fromCollection = ir.on.foreignCollection ?? "<self>";
+  const alias = lookupAlias(ir);
+
+  if (!isChained) {
+    const subPipeline = ir.to?._type
+      ? [{ $match: { _type: ir.to._type } }]
+      : undefined;
+    return {
+      $lookup: {
+        from: fromCollection,
+        localField: ir.on.localField,
+        foreignField: ir.on.foreignField,
+        ...(subPipeline && { pipeline: subPipeline }),
+        as: alias,
+      },
+    };
+  }
+
+  // Chained: lookup uses $let + $expr to dereference the parent alias.
+  const parentAlias = lookupAlias(ir.from as IndirectResource);
+  return {
+    $lookup: {
+      from: fromCollection,
+      let: {
+        src: { $arrayElemAt: [`$${parentAlias}.${ir.on.localField}`, 0] },
+      },
+      pipeline: [
+        {
+          $match: {
+            $expr: { $eq: [`$${ir.on.foreignField}`, "$$src"] },
+            ...(ir.to?._type && { _type: ir.to._type }),
+          },
+        },
+      ],
+      as: alias,
+    },
+  };
+}

package/indirect-resource.ts

@@ -0,0 +1,205 @@
+/**
+ * `indirectResource` — déclaration d'une ressource atteignable via une
+ * jointure (DB-pushdown via aggregation pipeline). Pendant de `resource()`
+ * pour les cas où la donnée filtrante vit dans une autre collection (ou
+ * dans la même via un foreign field).
+ *
+ * Cas d'usage typique :
+ *  - lister les `participant` qui ont une `org_membership` matching org=X
+ *  - lister les `participant` dont l'`user` lié appartient à entreprise=Y
+ *  - chaîner sur plusieurs niveaux (`participant → user → entreprise_member`)
+ *
+ * La méthode `.match()` retourne une `Rule` sentinelle (kind="indirect-match")
+ * que l'orchestrateur de `system.ts` détecte pour générer le pipeline
+ * d'aggregation correspondant — voir `indirect-aggregation.ts`.
+ *
+ * À la différence des ressources directes :
+ *  - Pas de `fetch` ni de `dedupKey` : aucune donnée chargée à l'évaluation
+ *  - Pas de rule `filter`/`include`/`require*` — uniquement `match` pour
+ *    contribuer une contrainte au pipeline généré.
+ */
+
+import { defineRule } from "./rules.ts";
+import { evaluateSpec, validateSpec } from "./mongo-query.ts";
+import type { FetchCtx, Rule } from "./types.ts";
+
+/**
+ * Identité de jointure entre une ressource source et la cible jointe.
+ *
+ * - `localField` : nom du champ sur le doc source.
+ * - `foreignField` : nom du champ sur le doc cible.
+ * - `foreignCollection` : si absent, jointure dans la même collection
+ *   (self-lookup) — utile pour les multi-collections mongodbee où le
+ *   discriminator de type vit dans un champ `_type`. Si présent,
+ *   jointure vers une collection externe (équivalent `externalLookup`).
+ */
+export interface IndirectResourceJoin {
+  readonly localField: string;
+  readonly foreignField: string;
+  readonly foreignCollection?: string;
+}
+
+/**
+ * Ressource indirecte. Identifie une cible joignable et expose des rules
+ * pour contribuer aux contraintes du pipeline généré.
+ *
+ * - `from` accepte une `Resource` directe (l'objet retourné par
+ *   `resource({...})`, sans champ `kind` — on le marque "direct" par
+ *   défaut) OU une autre `IndirectResource` (qui a `kind: "indirect"`)
+ *   pour chaîner sur plusieurs niveaux.
+ * - `to._type` discrimine le type cible quand la jointure vise une
+ *   collection multi-types (mongodbee). **Barrière de sécurité** : un
+ *   grant ne peut pas adresser un autre `_type` via le `with`.
+ * - `cardinality` indique si on attend N résultats (`many`) ou 1
+ *   (`one`) — utilisé pour optimiser le pipeline généré ($unwind potentiel).
+ */
+export interface IndirectResource {
+  readonly id: string;
+  /** Marker discriminant les ressources directes des indirectes. */
+  readonly kind: "indirect";
+  /** Normalisé au factory à partir du `from` du spec (Resource → direct). */
+  readonly from: { readonly id: string; readonly kind: "direct" | "indirect" };
+  readonly on: IndirectResourceJoin;
+  readonly to?: { readonly _type?: string };
+  readonly cardinality: "one" | "many";
+  /**
+   * Fetcher opt-in pour le mode concrete (per-doc check). Quand défini,
+   * la rule `match()` évalue effectivement la condition en mode concrete
+   * (au lieu d'être une sentinelle no-op). Reçoit la valeur de la source
+   * (déjà fetchée par l'engine) et retourne le tableau de docs joints.
+   *
+   * Toujours retourner un array, même pour `cardinality: "one"` — la
+   * sémantique du match utilise `$elemMatch`-like (au moins un match).
+   *
+   * Si absent, l'indirect reste sentinelle (legacy) : ne contribue qu'au
+   * pipeline en cap-mode.
+   */
+  readonly fetcher?: (
+    sourceDoc: unknown,
+    ctx: FetchCtx,
+  ) => readonly unknown[] | Promise<readonly unknown[]>;
+  /** Calcule la cache key pour un target (cf. `Resource.cacheKeyForTarget`). */
+  cacheKeyForTarget(target: readonly unknown[]): string;
+  /**
+   * Crée une rule qui déclare l'utilisation de cette resource indirecte
+   * dans la permission.
+   *
+   * - En cap-mode : sentinelle, détectée par `system.ts` qui collecte
+   *   l'indirect pour générer le pipeline (cf. `buildAggregationStages`).
+   * - En concrete-mode + `fetcher` défini : fetche les docs joints et
+   *   évalue `grant.with[id]` contre eux (au moins un doc match).
+   *   Sans `fetcher`, sentinelle aussi (no-op).
+   */
+  match(): Rule;
+}
+
+interface IndirectResourceSpec {
+  readonly id: string;
+  /**
+   * `Resource` (sans champ `kind`) ou `IndirectResource` (avec
+   * `kind: "indirect"`). Le factory normalise en stockant un
+   * `{ id, kind }` minimal pour la résolution du graphe.
+   */
+  readonly from: { readonly id: string; readonly kind?: "direct" | "indirect" };
+  readonly on: IndirectResourceJoin;
+  readonly to?: { readonly _type?: string };
+  readonly cardinality: "one" | "many";
+  readonly fetch?: (
+    sourceDoc: unknown,
+    ctx: FetchCtx,
+  ) => readonly unknown[] | Promise<readonly unknown[]>;
+}
+
+/**
+ * Sentinelle dans `Rule.descriptor` pour qu'`system.ts` reconnaisse
+ * cette rule comme "indirect" et collecte la resource correspondante.
+ *
+ * Le champ est typé `unknown` côté `RuleDescriptor` parce que
+ * `[extra: string]: unknown` est la signature catch-all des descriptors —
+ * on cast à l'extraction.
+ */
+export const INDIRECT_RULE_KIND = "indirect-match";
+
+export function indirectResource(spec: IndirectResourceSpec): IndirectResource {
+  // Normalize `from`: a `Resource` (from `resource({...})`) has no `kind`
+  // field; we treat it as "direct". An `IndirectResource` has
+  // `kind: "indirect"` set by this very factory. Walking the chain in
+  // the orchestrator reads `from.kind` to know whether to descend.
+  const fromNormalized = {
+    id: spec.from.id,
+    kind:
+      spec.from.kind === "indirect"
+        ? ("indirect" as const)
+        : ("direct" as const),
+  };
+  const impl: IndirectResource = {
+    id: spec.id,
+    kind: "indirect",
+    from: fromNormalized,
+    on: spec.on,
+    to: spec.to,
+    cardinality: spec.cardinality,
+    fetcher: spec.fetch,
+    cacheKeyForTarget(target: readonly unknown[]): string {
+      // Mirror of Resource.cacheKeyForTarget — the indirect's cache key
+      // is target-derived (typically by source dedup). Useful for
+      // `CanContext.preseed()` when the caller wants to inject joined
+      // docs already returned by a pipeline aggregation.
+      return `${spec.id}::${JSON.stringify(target)}`;
+    },
+    match() {
+      return defineRule({
+        kind: INDIRECT_RULE_KIND,
+        needs: [],
+        describe: () => ({ indirectResource: impl }),
+        check: (_data, _payload, ctx) => {
+          // Cap-mode : sentinelle. `system.ts` reads the descriptor and
+          // emits the pipeline via `buildAggregationStages`. The rule
+          // itself contributes nothing.
+          if (ctx.capability) return { ok: true };
+
+          // Concrete mode without fetcher : sentinelle aussi (legacy).
+          if (!impl.fetcher) return { ok: true };
+
+          // Concrete mode with fetcher : evaluate `grant.with[id]` spec
+          // against the joined docs. The engine already populated the
+          // joined docs in the context cache (see system.ts) — we just
+          // read them from `_indirectFetched` (an opaque per-rule pass).
+          // If no spec is set, the rule passes (the grant trusts the
+          // indirect resource without further check).
+          const spec = ctx.grant.with?.[impl.id];
+          if (spec === undefined) return { ok: true };
+          if (typeof spec === "object" && spec !== null) validateSpec(spec);
+
+          const joined =
+            (
+              ctx as FetchCtx & {
+                _indirectFetched?: Map<string, readonly unknown[]>;
+              }
+            )._indirectFetched?.get(impl.id) ?? [];
+          const passes = joined.some((d) =>
+            evaluateSpec(spec as Record<string, unknown>, d),
+          );
+          return passes
+            ? { ok: true }
+            : {
+                ok: false,
+                reason: `indirect[${impl.id}] no joined doc matches spec`,
+              };
+        },
+      });
+    },
+  };
+  return impl;
+}
+
+/**
+ * Extraction utilitaire pour `system.ts` : récupère la `IndirectResource`
+ * portée par une rule sentinelle, ou `null` si la rule n'en est pas une.
+ */
+export function extractIndirectResource(rule: Rule): IndirectResource | null {
+  if (rule.descriptor.kind !== INDIRECT_RULE_KIND) return null;
+  const ref = rule.descriptor.indirectResource;
+  if (!ref || typeof ref !== "object") return null;
+  return ref as IndirectResource;
+}

package/mod.ts

@@ -0,0 +1,81 @@
+/**
+ * `@diister/quick-permission` — API publique.
+ *
+ * Expose une primitive unique `defineRule({ needs, check })` autour de
+ * laquelle sont organisés les `Resource`, méthodes de sucre, et le moteur
+ * d'orchestration avec dedup par contexte.
+ *
+ * Cf. `docs/rfc-resource-pipe-api.md` pour la motivation, les décisions
+ * de design et le plan de migration.
+ */
+
+// ─── Targets ─────────────────────────────────────────────────────────────
+export { seg, target } from "./target.ts";
+
+// ─── Core types ──────────────────────────────────────────────────────────
+export type {
+  AnySegment,
+  AnyTarget,
+  CanResult,
+  FetchCtx,
+  FilterContribution,
+  Grant,
+  IndirectResourceInfo,
+  ListEntry,
+  Permission,
+  Resource,
+  ResourceData,
+  ResourcesData,
+  Rule,
+  RuleDescriptor,
+  RuleResult,
+  SegmentSpec,
+  SerializableSegment,
+  SerializableTarget,
+  SpecToSegment,
+  Subject,
+  TargetArgs,
+  TargetNone,
+  TargetOptional,
+  TargetPath,
+  TargetRequired,
+  TreeNode,
+} from "./types.ts";
+
+// ─── Resource factory + sugar methods ────────────────────────────────────
+export { resource } from "./resource.ts";
+
+// ─── Indirect resource (JOIN-based, generates aggregation pipeline) ──────
+export { indirectResource } from "./indirect-resource.ts";
+export type {
+  IndirectResource,
+  IndirectResourceJoin,
+} from "./indirect-resource.ts";
+export type { AggregationStage } from "./indirect-aggregation.ts";
+
+// ─── defineRule + standalone helpers ─────────────────────────────────────
+export { defineRule, inputMatch, matchPath, requireSelf } from "./rules.ts";
+export type { DefineRuleOpts } from "./rules.ts";
+
+// ─── Permission builders ─────────────────────────────────────────────────
+export { intermediate, permission } from "./permission.ts";
+export type {
+  IntermediateBuilder,
+  IntermediateConfig,
+  PermissionBuilder,
+  PermissionConfig,
+} from "./permission.ts";
+
+// ─── System ──────────────────────────────────────────────────────────────
+export { createSystem } from "./system.ts";
+export type {
+  CanContext,
+  Provider,
+  ProviderFn,
+  ProviderObject,
+  System,
+} from "./system.ts";
+
+// ─── Field-projection helpers (used outside permission checks too) ───────
+export { applyFilter, pickFields } from "./core/filtering.ts";
+export type { FilterSpec } from "./core/merging.ts";

package/mongo-query.ts

@@ -0,0 +1,94 @@
+/**
+ * Évaluateur d'expressions style MongoDB query basé sur `sift`.
+ *
+ * Sift supporte ~100% du Mongo query language en pur JS. On délègue
+ * l'évaluation à sift mais on **valide la spec en amont** pour s'assurer
+ * qu'aucun opérateur dangereux n'est utilisé (`$where`, `$function`, etc.
+ * permettent de l'exécution de code arbitraire — interdits dans un grant
+ * qui peut venir de la DB).
+ *
+ * Whitelist :
+ *   - Comparaisons : `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`
+ *   - Existence    : `$exists`, `$type`
+ *   - Logiques     : `$and`, `$or`, `$nor`, `$not`
+ *   - String       : `$regex`, `$options`
+ *   - Tableaux     : `$all`, `$elemMatch`, `$size`
+ *
+ * Interdit (pas dans la whitelist, throw au boot ou au check) :
+ *   - `$where`, `$function`, `$expr`, `$jsonSchema`, `$accumulator`
+ *
+ * La même spec sert à :
+ *  1. Évaluer en mémoire un document (per-doc check via sift)
+ *  2. Filtrer une collection MongoDB en pushdown (la spec EST déjà du Mongo)
+ */
+
+import sift from "./sift/index.ts";
+
+const ALLOWED_OPERATORS: ReadonlySet<string> = new Set([
+  // Comparison
+  "$eq",
+  "$ne",
+  "$in",
+  "$nin",
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte",
+  // Existence / type
+  "$exists",
+  "$type",
+  // Logical
+  "$and",
+  "$or",
+  "$nor",
+  "$not",
+  // String
+  "$regex",
+  "$options",
+  // Array
+  "$all",
+  "$elemMatch",
+  "$size",
+]);
+
+export type MongoSpec = Record<string, unknown>;
+
+/**
+ * Vérifie récursivement qu'aucun opérateur non-whitelisté n'est présent
+ * dans la spec. Throw au premier opérateur interdit (`$where`, etc.).
+ *
+ * À appeler à la création du grant (validation côté API) ou au pire au
+ * check time, pour empêcher l'exécution de code arbitraire.
+ */
+export function validateSpec(spec: unknown, path = "$"): void {
+  if (spec === null || typeof spec !== "object") return;
+  if (Array.isArray(spec)) {
+    // A `for` loop, not `forEach`: the arrow's implicit return handed back
+    // validateSpec's value, which the iteration then discarded.
+    for (const [i, item] of spec.entries()) {
+      validateSpec(item, `${path}[${i}]`);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(spec as object)) {
+    if (key.startsWith("$")) {
+      if (!ALLOWED_OPERATORS.has(key)) {
+        throw new Error(
+          `Forbidden Mongo operator at ${path}: "${key}". ` +
+            `Allowed: ${[...ALLOWED_OPERATORS].join(", ")}`,
+        );
+      }
+    }
+    validateSpec(value, `${path}.${key}`);
+  }
+}
+
+/**
+ * Évalue une spec contre un document. La spec est validée d'abord pour
+ * rejeter tout opérateur non-whitelisté.
+ */
+export function evaluateSpec(spec: MongoSpec, doc: unknown): boolean {
+  validateSpec(spec);
+  // deno-lint-ignore no-explicit-any
+  return (sift as any)(spec)(doc);
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@diister/quick-permission",
+  "version": "0.9.0-beta.5",
+  "description": "Declarative, type-safe permission rules with MongoDB query generation",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "keywords": [
+    "permissions",
+    "authorization",
+    "access-control",
+    "mongodb",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diister-dev/quick-permission.git",
+    "directory": "library"
+  },
+  "homepage": "https://github.com/diister-dev/quick-permission#readme",
+  "bugs": "https://github.com/diister-dev/quick-permission/issues",
+  "engines": {
+    "node": ">=20.11"
+  },
+  "files": [
+    "dist",
+    "core",
+    "sift",
+    "*.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.12",
+    "@types/bun": "^1.4.1",
+    "@types/node": "^22.15.0",
+    "mongodb": "^6.21.0",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "check:package": "bun run scripts/check-package.ts",
+    "version:set": "bun run scripts/check-package.ts --write",
+    "prebuild": "bun run check:package",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "lint": "biome lint .",
+    "fmt": "biome format --write .",
+    "fmt:check": "biome format .",
+    "test": "bun test"
+  }
+}