@fitzzero/quickdraw-core 5.1.0 → 5.1.2

package/dist/{chunk-DD4SKCNO.js → chunk-LCC7HNFP.js}

@@ -1,3 +1,7 @@
+import {
+  isPrismaError,
+  prismaSummary
+} from "./chunk-DKE6QO26.js";
 import {
   QuickdrawError
 } from "./chunk-4YO5H5ON.js";
@@ -7,6 +11,13 @@ function describeError(error, depth = 0) {
   if (!(error instanceof Error)) {
     return { value: String(error) };
   }
+  if (isPrismaError(error)) {
+    const summary = prismaSummary(error);
+    if (error.cause !== void 0 && depth < 3) {
+      summary.cause = describeError(error.cause, depth + 1);
+    }
+    return summary;
+  }
   const described = {
     name: error.name,
     message: error.message,
@@ -83,4 +94,4 @@ export {
   failureLevel,
   createRecorder
 };
-//# sourceMappingURL=chunk-DD4SKCNO.js.map
+//# sourceMappingURL=chunk-LCC7HNFP.js.map

package/dist/chunk-LCC7HNFP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server/pipeline/metrics.ts"],"sourcesContent":["// The completion record (RFC 0003 section 9, step 9) and call logging. Every\n// call produces exactly one record, handed to `onCall`, and one log entry:\n// `debug` normally, `warn` when slower than `slowMs` or larger than\n// `maxResponseBytes`, `error` when the call failed with `INTERNAL` or\n// `TIMEOUT` (the failures that are the server's fault). An `INTERNAL`\n// entry carries the original error with its stack. This replaces 4.1's two\n// `info` entries per call (4.1 `src/server/ServiceRegistry.ts:331-373`).\n\nimport { isPrismaError, prismaSummary, type Logger } from \"../../contract/logger\";\nimport type { MethodKind } from \"../../contract/methods\";\nimport { QuickdrawError, type ErrorCode } from \"../../protocol/errors\";\nimport type { DevWarnings } from \"../devWarnings\";\nimport type { Transport } from \"../types\";\n\n/** How a call ended: `\"ok\"`, `\"not-modified\"`, or the error code it failed with. */\nexport type CallOutcome = \"ok\" | \"not-modified\" | ErrorCode;\n\n/** One call's completion record, handed to the dispatcher's `onCall`. */\nexport interface CallRecord {\n  readonly service: string;\n  readonly method: string;\n  /** `undefined` when the method does not exist. */\n  readonly kind: MethodKind | undefined;\n  readonly transport: Transport;\n  readonly requestId: string;\n  readonly outcome: CallOutcome;\n  /** From the call's arrival until its result was ready, in milliseconds. */\n  readonly durationMs: number;\n  /** Time spent waiting for a query slot, in milliseconds. */\n  readonly queueMs: number;\n  /** The reply's size as the transport measured it; 0 when it measured nothing. */\n  readonly bytes: number;\n  /** True when the result came from another call's run of the same query, or its `ttlMs` cache. */\n  readonly shared: boolean;\n  /**\n   * Database statements the handler run issued, when the unit of work counts\n   * them: the handler's own reads and writes, the reads a kit handler makes\n   * to filter by access included. The access check before the handler (its\n   * reads run before the unit opens), the flush after it and the per-caller\n   * strip of field tiers are not counted. A shared run is counted once, on\n   * the call that started it; a call that joined it reports `undefined`.\n   */\n  readonly sqlStatements: number | undefined;\n}\n\n/** Options of {@link createRecorder}. */\nexport interface RecorderOptions {\n  readonly logger: Logger;\n  readonly onCall: ((record: CallRecord) => void) | undefined;\n  readonly slowMs: number;\n  readonly maxResponseBytes: number;\n  /** Raises `oversized-response` for a reply over `maxResponseBytes`. */\n  readonly warnings?: DevWarnings;\n}\n\n/** What a record is logged with besides the record itself. */\nexport interface RecordDetails {\n  /** The error the call failed with. */\n  readonly error?: QuickdrawError;\n  /** The caller's user id, for the log only. */\n  readonly userId?: string;\n}\n\n/**\n * The parts of an error worth logging, including its stack and cause. A\n * Prisma error is summarized: its message renders the call, values\n * included.\n */\nexport function describeError(error: unknown, depth = 0): Record<string, unknown> {\n  if (!(error instanceof Error)) {\n    return { value: String(error) };\n  }\n  if (isPrismaError(error)) {\n    const summary = prismaSummary(error);\n    if (error.cause !== undefined && depth < 3) {\n      summary.cause = describeError(error.cause, depth + 1);\n    }\n    return summary;\n  }\n  const described: Record<string, unknown> = {\n    name: error.name,\n    message: error.message,\n    stack: error.stack,\n  };\n  if (\"code\" in error) {\n    described.code = error.code;\n  }\n  if (\"data\" in error && error.data !== undefined) {\n    described.data = error.data;\n  }\n  if (error.cause !== undefined && depth < 3) {\n    described.cause = describeError(error.cause, depth + 1);\n  }\n  return described;\n}\n\ntype Level = \"debug\" | \"warn\" | \"error\";\n\n/** True for the codes of server faults, which log at error; every other code the client caused. */\nfunction isFault(code: unknown): boolean {\n  return code === \"INTERNAL\" || code === \"TIMEOUT\";\n}\n\n/**\n * The level a failure outside a call logs at, as a call's failure does:\n * `debug` for a `QuickdrawError` the client caused (any code but `INTERNAL`\n * and `TIMEOUT`), else `error`. A channel handler refusing a payload must\n * not fill the error log.\n */\nexport function failureLevel(error: unknown): \"debug\" | \"error\" {\n  return error instanceof QuickdrawError && !isFault(error.code) ? \"debug\" : \"error\";\n}\n\nfunction levelOf(record: CallRecord, options: RecorderOptions): Level {\n  if (isFault(record.outcome)) {\n    return \"error\";\n  }\n  const slow = record.durationMs > options.slowMs;\n  return slow || record.bytes > options.maxResponseBytes ? \"warn\" : \"debug\";\n}\n\n/** Hands `record` to `onCall`; what it throws is logged, never thrown. */\nfunction emit(options: RecorderOptions, record: CallRecord): void {\n  if (options.onCall === undefined) {\n    return;\n  }\n  try {\n    options.onCall(record);\n  } catch (error) {\n    options.logger.error(\"onCall threw; the call was not affected\", {\n      category: \"quickdraw.call\",\n      error: describeError(error),\n    });\n  }\n}\n\n/**\n * The `oversized-response` development warning, for a method whose reply\n * was larger than `maxResponseBytes`. It is raised after the record went to\n * `onCall`, because a strict test app throws it.\n */\nfunction warnOversized(options: RecorderOptions, record: CallRecord): void {\n  if (record.kind === undefined || record.bytes <= options.maxResponseBytes) {\n    return;\n  }\n  options.warnings?.warn({\n    kind: \"oversized-response\",\n    service: record.service,\n    method: record.method,\n    message:\n      `replied with ${record.bytes} bytes, more than maxResponseBytes (${options.maxResponseBytes}); ` +\n      \"page the result (take and a cursor), return a leaner projection, or serve it as a collection\",\n    meta: { bytes: record.bytes, maxResponseBytes: options.maxResponseBytes },\n  });\n}\n\n/**\n * Returns the function that logs a call's record and hands it to `onCall`.\n * In a strict test app it throws an oversized reply's `DevWarningError`\n * once it has done both.\n */\nexport function createRecorder(\n  options: RecorderOptions,\n): (record: CallRecord, details: RecordDetails) => void {\n  return (record, details) => {\n    const meta: Record<string, unknown> = { category: \"quickdraw.call\", ...record };\n    if (details.userId !== undefined) {\n      meta.userId = details.userId;\n    }\n    if (details.error !== undefined) {\n      meta.error = describeError(details.error);\n    }\n    const duration = Math.round(record.durationMs);\n    const message = `${record.service}.${record.method} ${record.outcome} in ${duration} ms`;\n    options.logger[levelOf(record, options)](message, meta);\n    emit(options, record);\n    warnOversized(options, record);\n  };\n}\n"],"mappings":";;;;;;;;;AAoEO,SAAS,cAAc,OAAgB,QAAQ,GAA4B;AAChF,MAAI,EAAE,iBAAiB,QAAQ;AAC7B,WAAO,EAAE,OAAO,OAAO,KAAK,EAAE;AAAA,EAChC;AACA,MAAI,cAAc,KAAK,GAAG;AACxB,UAAM,UAAU,cAAc,KAAK;AACnC,QAAI,MAAM,UAAU,UAAa,QAAQ,GAAG;AAC1C,cAAQ,QAAQ,cAAc,MAAM,OAAO,QAAQ,CAAC;AAAA,IACtD;AACA,WAAO;AAAA,EACT;AACA,QAAM,YAAqC;AAAA,IACzC,MAAM,MAAM;AAAA,IACZ,SAAS,MAAM;AAAA,IACf,OAAO,MAAM;AAAA,EACf;AACA,MAAI,UAAU,OAAO;AACnB,cAAU,OAAO,MAAM;AAAA,EACzB;AACA,MAAI,UAAU,SAAS,MAAM,SAAS,QAAW;AAC/C,cAAU,OAAO,MAAM;AAAA,EACzB;AACA,MAAI,MAAM,UAAU,UAAa,QAAQ,GAAG;AAC1C,cAAU,QAAQ,cAAc,MAAM,OAAO,QAAQ,CAAC;AAAA,EACxD;AACA,SAAO;AACT;AAKA,SAAS,QAAQ,MAAwB;AACvC,SAAO,SAAS,cAAc,SAAS;AACzC;AAQO,SAAS,aAAa,OAAmC;AAC9D,SAAO,iBAAiB,kBAAkB,CAAC,QAAQ,MAAM,IAAI,IAAI,UAAU;AAC7E;AAEA,SAAS,QAAQ,QAAoB,SAAiC;AACpE,MAAI,QAAQ,OAAO,OAAO,GAAG;AAC3B,WAAO;AAAA,EACT;AACA,QAAM,OAAO,OAAO,aAAa,QAAQ;AACzC,SAAO,QAAQ,OAAO,QAAQ,QAAQ,mBAAmB,SAAS;AACpE;AAGA,SAAS,KAAK,SAA0B,QAA0B;AAChE,MAAI,QAAQ,WAAW,QAAW;AAChC;AAAA,EACF;AACA,MAAI;AACF,YAAQ,OAAO,MAAM;AAAA,EACvB,SAAS,OAAO;AACd,YAAQ,OAAO,MAAM,2CAA2C;AAAA,MAC9D,UAAU;AAAA,MACV,OAAO,cAAc,KAAK;AAAA,IAC5B,CAAC;AAAA,EACH;AACF;AAOA,SAAS,cAAc,SAA0B,QAA0B;AACzE,MAAI,OAAO,SAAS,UAAa,OAAO,SAAS,QAAQ,kBAAkB;AACzE;AAAA,EACF;AACA,UAAQ,UAAU,KAAK;AAAA,IACrB,MAAM;AAAA,IACN,SAAS,OAAO;AAAA,IAChB,QAAQ,OAAO;AAAA,IACf,SACE,gBAAgB,OAAO,KAAK,uCAAuC,QAAQ,gBAAgB;AAAA,IAE7F,MAAM,EAAE,OAAO,OAAO,OAAO,kBAAkB,QAAQ,iBAAiB;AAAA,EAC1E,CAAC;AACH;AAOO,SAAS,eACd,SACsD;AACtD,SAAO,CAAC,QAAQ,YAAY;AAC1B,UAAM,OAAgC,EAAE,UAAU,kBAAkB,GAAG,OAAO;AAC9E,QAAI,QAAQ,WAAW,QAAW;AAChC,WAAK,SAAS,QAAQ;AAAA,IACxB;AACA,QAAI,QAAQ,UAAU,QAAW;AAC/B,WAAK,QAAQ,cAAc,QAAQ,KAAK;AAAA,IAC1C;AACA,UAAM,WAAW,KAAK,MAAM,OAAO,UAAU;AAC7C,UAAM,UAAU,GAAG,OAAO,OAAO,IAAI,OAAO,MAAM,IAAI,OAAO,OAAO,OAAO,QAAQ;AACnF,YAAQ,OAAO,QAAQ,QAAQ,OAAO,CAAC,EAAE,SAAS,IAAI;AACtD,SAAK,SAAS,MAAM;AACpB,kBAAc,SAAS,MAAM;AAAA,EAC/B;AACF;","names":[]}

package/dist/{chunk-2PWMUVC7.js → chunk-MBH6IDSM.js}

@@ -1,3 +1,7 @@
+import {
+  ACCESS_LEVELS,
+  isAccessLevel
+} from "./chunk-AK23XSWD.js";
 import {
   hasJsonSchema,
   isStandardSchema,
@@ -9,6 +13,388 @@ import {
   isErrorCode
 } from "./chunk-4YO5H5ON.js";
 
+// src/server/access/levels.ts
+var RANK = Object.freeze({
+  Public: 0,
+  Read: 1,
+  Moderate: 2,
+  Admin: 3
+});
+function meetsLevel(level, required) {
+  if (level === null || level === void 0) {
+    return false;
+  }
+  return (RANK[level] ?? -1) >= RANK[required];
+}
+function maxLevel(a, b) {
+  const left = isAccessLevel(a) ? a : null;
+  const right = isAccessLevel(b) ? b : null;
+  if (left === null || right === null) {
+    return left ?? right;
+  }
+  return RANK[right] > RANK[left] ? right : left;
+}
+function levelsAtLeast(required) {
+  return ACCESS_LEVELS.filter((level) => RANK[level] >= RANK[required]);
+}
+function serviceGrant(principal, service) {
+  const grants = principal.serviceAccess;
+  if (grants === null || grants === void 0 || !Object.hasOwn(grants, service)) {
+    return void 0;
+  }
+  return grants[service];
+}
+
+// src/server/emit/tiers.ts
+var SUBSCRIBE_LEVEL = "Read";
+var SUBSCRIBER_LEVELS = Object.freeze([
+  "Read",
+  "Moderate",
+  "Admin"
+]);
+var NOTHING = Object.freeze(/* @__PURE__ */ new Set());
+function hiddenAt(fields, keys, level) {
+  const hidden = keys.filter((key) => {
+    const required = Object.hasOwn(fields, key) ? fields[key] : void 0;
+    return required !== void 0 && !meetsLevel(level, required);
+  });
+  return hidden.length === 0 ? NOTHING : Object.freeze(new Set(hidden));
+}
+function tiersOf(fields, keys) {
+  const byLevel = /* @__PURE__ */ new Map();
+  const labels = /* @__PURE__ */ new Map();
+  const hiding = (level) => {
+    let found = byLevel.get(level);
+    if (found === void 0) {
+      const set = hiddenAt(fields, keys, level);
+      const signature = [...set].join("\0");
+      const label = labels.get(signature) ?? String.fromCodePoint(97 + labels.size);
+      labels.set(signature, label);
+      found = { hidden: set, label };
+      byLevel.set(level, found);
+    }
+    return found;
+  };
+  const hidden = (level) => hiding(level).hidden;
+  const groups = /* @__PURE__ */ new Map();
+  for (const level of SUBSCRIBER_LEVELS) {
+    const set = hidden(level);
+    const signature = [...set].join("\0");
+    const group = groups.get(signature);
+    if (group === void 0) {
+      groups.set(signature, { levels: [level], hidden: set });
+    } else {
+      group.levels.push(level);
+    }
+  }
+  return Object.freeze({
+    tiered: keys.some((key) => Object.hasOwn(fields, key)),
+    hidden,
+    label: (level) => hiding(level).label,
+    groups: Object.freeze([...groups.values()].map((group) => Object.freeze(group)))
+  });
+}
+function strip(row, hidden) {
+  if (hidden.size === 0) {
+    return row;
+  }
+  const kept = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (!hidden.has(key)) {
+      kept[key] = value;
+    }
+  }
+  return kept;
+}
+
+// src/server/emit/projection.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlain(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return Array.isArray(value) || prototype === Object.prototype || prototype === null;
+}
+function referenced(node, root) {
+  const ref = node.$ref;
+  if (typeof ref !== "string") {
+    return node;
+  }
+  if (ref === "#") {
+    return root;
+  }
+  const match = /^#\/(definitions|\$defs)\/(.+)$/.exec(ref);
+  const defs = match === null ? void 0 : root[match[1] ?? ""];
+  const name = (match?.[2] ?? "").replaceAll("~1", "/").replaceAll("~0", "~");
+  const target = isRecord(defs) ? defs[name] : void 0;
+  return isRecord(target) ? target : void 0;
+}
+function pointerToken(name) {
+  return name.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function schemaKeys(schema) {
+  if (!hasJsonSchema(schema)) {
+    return void 0;
+  }
+  let json;
+  try {
+    json = schema["~standard"].jsonSchema.output({ target: "draft-07" });
+  } catch {
+    return void 0;
+  }
+  const described = isRecord(json) ? referenced(json, json) : void 0;
+  const properties = described?.properties;
+  return isRecord(properties) ? Object.keys(properties) : void 0;
+}
+var BRANCHES = ["anyOf", "oneOf", "allOf"];
+var UNREPRESENTABLE_AS_ANY = Object.freeze({ unrepresentable: "any" });
+function addBranchKeys(node, root, keys, seen) {
+  const target = isRecord(node) ? referenced(node, root) : void 0;
+  if (target === void 0 || seen.has(target)) {
+    return;
+  }
+  seen.add(target);
+  if (isRecord(target.properties)) {
+    for (const key of Object.keys(target.properties)) {
+      keys.add(key);
+    }
+  }
+  for (const keyword of BRANCHES) {
+    const members = target[keyword];
+    if (Array.isArray(members)) {
+      for (const member of members) {
+        addBranchKeys(member, root, keys, seen);
+      }
+    }
+  }
+}
+function inputKeys(schema) {
+  if (!hasJsonSchema(schema)) {
+    return void 0;
+  }
+  let json;
+  try {
+    json = schema["~standard"].jsonSchema.input({
+      target: "draft-07",
+      libraryOptions: UNREPRESENTABLE_AS_ANY
+    });
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(json)) {
+    return void 0;
+  }
+  const keys = /* @__PURE__ */ new Set();
+  addBranchKeys(json, json, keys, /* @__PURE__ */ new Set());
+  return [...keys];
+}
+var OPTION_KEYS = /* @__PURE__ */ new Set(["keys", "select", "map"]);
+function checkKeyList(owner, keys, fail) {
+  const valid = Array.isArray(keys) && keys.every((key) => typeof key === "string" && key.length > 0) && new Set(keys).size === keys.length;
+  if (!valid) {
+    fail(`${owner}: keys must be a list of distinct field names`);
+  }
+  if (!keys.includes("id")) {
+    fail(`${owner}: keys must include "id"; every row is keyed by it`);
+  }
+  return keys;
+}
+function checkOption(owner, option, fail) {
+  if (option === void 0) {
+    return {};
+  }
+  if (!isRecord(option)) {
+    fail(`${owner} must be { keys?, select?, map? }`);
+  }
+  const unknownKey = Object.keys(option).find((key) => !OPTION_KEYS.has(key));
+  if (unknownKey !== void 0) {
+    fail(`${owner} has an unknown option "${unknownKey}"; the options are keys, select and map`);
+  }
+  if (option.select !== void 0 && !isRecord(option.select)) {
+    fail(`${owner}: select must be a select object, as in { id: true, labels: { select: ... } }`);
+  }
+  if (option.map !== void 0 && typeof option.map !== "function") {
+    fail(`${owner}: map must be a function of the row its select reads`);
+  }
+  return option;
+}
+function keysFor(name, schema, option, fail) {
+  const owner = `projection "${name}"`;
+  if (option.keys !== void 0) {
+    return checkKeyList(owner, option.keys, fail);
+  }
+  const keys = schemaKeys(schema);
+  if (keys === void 0) {
+    fail(
+      `${owner}: its schema cannot list its keys (it has no Standard JSON Schema the framework can read); use Zod 4.2 or later for it, or declare them with project: { ${name}: { keys: [...] } }`
+    );
+  }
+  return keys;
+}
+function compileOne(name, schema, option, fields, fail) {
+  const checked = checkOption(`projection "${name}"`, option, fail);
+  const keys = keysFor(name, schema, checked, fail);
+  const ordered = ["id", ...keys.filter((key) => key !== "id")];
+  const select = isRecord(checked.select) ? { id: true, ...checked.select } : Object.fromEntries(ordered.map((key) => [key, true]));
+  return Object.freeze({
+    name,
+    keys: Object.freeze(ordered),
+    select: Object.freeze(select),
+    map: checked.map,
+    tiers: tiersOf(fields, ordered)
+  });
+}
+function compileProjections(contract, option, fail) {
+  if (option !== void 0 && !isRecord(option)) {
+    fail("project must map projection names to { keys?, select?, map? }");
+  }
+  const options = option ?? {};
+  const schemas = new Map(Object.entries(contract.projections));
+  if (contract.entity !== void 0) {
+    schemas.set("entity", contract.entity);
+  }
+  const unknownName = Object.keys(options).find((name) => !schemas.has(name));
+  if (unknownName !== void 0) {
+    fail(
+      `project names "${unknownName}", which is not a projection of the contract; the projections are ${[...schemas.keys()].map((name) => `"${name}"`).join(", ") || "none"}`
+    );
+  }
+  const compiled = /* @__PURE__ */ new Map();
+  for (const [name, schema] of schemas) {
+    compiled.set(name, compileOne(name, schema, options[name], contract.fields, fail));
+  }
+  return compiled;
+}
+function projectedOutput(output, projections) {
+  if (typeof output === "string") {
+    const projection2 = projections.get(output);
+    return projection2 === void 0 ? void 0 : { projection: projection2, kind: "one" };
+  }
+  if (!("kind" in output)) {
+    return void 0;
+  }
+  const projection = projections.get(output.projection);
+  const kind = output.kind === "nullable" ? "nullable" : "list";
+  return projection === void 0 ? void 0 : { projection, kind };
+}
+function isoDates(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (!isPlain(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(isoDates);
+  }
+  const copy = {};
+  for (const [key, item] of Object.entries(value)) {
+    copy[key] = isoDates(item);
+  }
+  return copy;
+}
+function pickKeys(row, keys) {
+  const picked = {};
+  for (const key of keys) {
+    if (Object.hasOwn(row, key)) {
+      picked[key] = isoDates(row[key]);
+    }
+  }
+  return picked;
+}
+function projectRow(projection, row) {
+  if (!isRecord(row)) {
+    return row;
+  }
+  const source = projection.map === void 0 ? row : projection.map(row);
+  return isRecord(source) ? pickKeys(source, projection.keys) : source;
+}
+function projectOutput(output, value) {
+  if (output.kind === "list") {
+    return Array.isArray(value) ? value.map((row) => projectRow(output.projection, row)) : value;
+  }
+  if (value === null && output.kind === "nullable") {
+    return null;
+  }
+  return projectRow(output.projection, value);
+}
+function rowIds(value) {
+  const rows = Array.isArray(value) ? value : [value];
+  const ids = [];
+  for (const row of rows) {
+    if (isRecord(row) && typeof row.id === "string" && row.id.length > 0) {
+      ids.push(row.id);
+    }
+  }
+  return ids;
+}
+function wholeView(value) {
+  return { key: "", strip: () => value };
+}
+async function readerView(output, value, levelsOf) {
+  const { tiers } = output.projection;
+  if (!tiers.tiered || value === null || value === void 0) {
+    return wholeView(value);
+  }
+  const ids = [...new Set(rowIds(value))];
+  const levels = ids.length === 0 ? /* @__PURE__ */ new Map() : await levelsOf(ids);
+  const levelOf = (row) => typeof row.id === "string" ? levels.get(row.id) ?? null : null;
+  const rows = Array.isArray(value) ? value : [value];
+  const key = rows.map((row) => isRecord(row) ? tiers.label(levelOf(row)) : "-").join("");
+  const one = (row) => isRecord(row) ? strip(row, tiers.hidden(levelOf(row))) : row;
+  return { key, strip: () => Array.isArray(value) ? value.map(one) : one(value) };
+}
+
+// src/server/service.ts
+var runtimes = /* @__PURE__ */ new WeakMap();
+function registerRuntime(service, runtime) {
+  runtimes.set(service, runtime);
+}
+function runtimeOf(service) {
+  return typeof service === "object" && service !== null ? runtimes.get(service) : void 0;
+}
+var handlerChecks = /* @__PURE__ */ new WeakMap();
+function checkWhenDefined(handler, check) {
+  handlerChecks.set(handler, check);
+}
+var grantsEditors = /* @__PURE__ */ new WeakSet();
+function markGrantsEditor(handler) {
+  grantsEditors.add(handler);
+}
+function editsGrants(handler) {
+  return grantsEditors.has(handler);
+}
+function handlerProblem(handler, service) {
+  return handlerChecks.get(handler)?.(service);
+}
+var servedChecks = /* @__PURE__ */ new WeakMap();
+function checkWhenServed(handler, check) {
+  servedChecks.set(handler, check);
+}
+function servedProblem(handler, served) {
+  return servedChecks.get(handler)?.(served);
+}
+function isKitHandler(handler) {
+  return handlerChecks.has(handler);
+}
+var rowChecked = /* @__PURE__ */ new WeakSet();
+function checksRowsItself(handler) {
+  rowChecked.add(handler);
+}
+function isRowChecked(handler) {
+  return rowChecked.has(handler);
+}
+var callerDependent = /* @__PURE__ */ new WeakSet();
+function dependsOnCaller(handler) {
+  callerDependent.add(handler);
+}
+function isCallerDependent(handler) {
+  return callerDependent.has(handler);
+}
+
 // src/server/caller.ts
 var CALLER_GRANTS = /* @__PURE__ */ new WeakMap();
 function setCallerGrants(dispatcher, grants) {
@@ -107,6 +493,44 @@ function createCaller(resolve, principal, settings = {}) {
   );
 }
 
+// src/server/access/kinds.ts
+function isKindList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((kind) => typeof kind === "string" && kind.length > 0);
+}
+function narrowKinds(value, above, fail) {
+  if (value === void 0) {
+    return above?.kinds;
+  }
+  if (!isKindList(value)) {
+    fail(
+      'kinds must be a non-empty list of principal kinds (strings), such as ["user"]; leave it out to admit every kind'
+    );
+  }
+  if (above?.kinds !== void 0) {
+    const { kinds, by } = above;
+    const wider = value.find((kind) => !kinds.includes(kind));
+    if (wider !== void 0) {
+      fail(
+        `kinds may only narrow the kinds ${by} admits (${kinds.join(", ")}), and "${wider}" is not one of them`
+      );
+    }
+  }
+  return Object.freeze([...new Set(value)]);
+}
+function checkKind(kinds, principal, what) {
+  if (kinds === void 0 || principal === null) {
+    return;
+  }
+  const { kind } = principal;
+  if (typeof kind === "string" && kinds.includes(kind)) {
+    return;
+  }
+  throw new QuickdrawError(
+    "FORBIDDEN",
+    kind === void 0 ? `${what} is not open to a principal without a kind` : `${what} is not open to principals of kind "${String(kind)}"`
+  );
+}
+
 // src/server/pipeline/errors.ts
 function cancelledError() {
   return new QuickdrawError("CANCELLED", "The call was cancelled");
@@ -147,7 +571,7 @@ function toQuickdrawError(error) {
 
 // src/server/pipeline/schemaOutput.ts
 var ANY = Object.freeze({ any: true, object: void 0, array: void 0 });
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPlainObject(value) {
@@ -169,11 +593,11 @@ function follow(ref, root) {
     } catch {
       return void 0;
     }
-    node = isRecord(node) && Object.hasOwn(node, part) ? node[part] : void 0;
+    node = isRecord2(node) && Object.hasOwn(node, part) ? node[part] : void 0;
   }
   return node;
 }
-var BRANCHES = ["anyOf", "oneOf", "allOf"];
+var BRANCHES2 = ["anyOf", "oneOf", "allOf"];
 function hasAny(node, keywords) {
   return keywords.some((keyword) => node[keyword] !== void 0);
 }
@@ -222,7 +646,7 @@ var Compiler = class {
     if (value === void 0 || value === true) {
       return this.make(true);
     }
-    if (!isRecord(value)) {
+    if (!isRecord2(value)) {
       return this.make(false);
     }
     const known = this.nodes.get(value);
@@ -242,7 +666,7 @@ var Compiler = class {
       const target = follow($ref, this.root);
       node.members.push(target === void 0 ? this.make(true) : this.read(target));
     }
-    for (const keyword of BRANCHES) {
+    for (const keyword of BRANCHES2) {
       const members = json[keyword];
       if (!Array.isArray(members)) {
         continue;
@@ -280,14 +704,14 @@ var Compiler = class {
   }
   readObject(json) {
     const properties = /* @__PURE__ */ new Map();
-    if (isRecord(json.properties)) {
+    if (isRecord2(json.properties)) {
       for (const [key, schema] of Object.entries(json.properties)) {
         properties.set(key, this.read(schema));
       }
     }
     const patterns = [];
     let open = false;
-    if (isRecord(json.patternProperties)) {
+    if (isRecord2(json.patternProperties)) {
       for (const [source, schema] of Object.entries(json.patternProperties)) {
         const regex = patternOf(source);
         if (regex === void 0) {
@@ -491,7 +915,7 @@ function keyPaths(root) {
   }
   return paths;
 }
-var UNREPRESENTABLE_AS_ANY = Object.freeze({ unrepresentable: "any" });
+var UNREPRESENTABLE_AS_ANY2 = Object.freeze({ unrepresentable: "any" });
 function compileSchemaOutput(schema) {
   if (!hasJsonSchema(schema)) {
     return void 0;
@@ -500,12 +924,12 @@ function compileSchemaOutput(schema) {
   try {
     json = schema["~standard"].jsonSchema.output({
       target: "draft-07",
-      libraryOptions: UNREPRESENTABLE_AS_ANY
+      libraryOptions: UNREPRESENTABLE_AS_ANY2
     });
   } catch {
     return void 0;
   }
-  if (!isRecord(json)) {
+  if (!isRecord2(json)) {
     return void 0;
   }
   const compiler = new Compiler(json);
@@ -678,8 +1102,51 @@ function withSignal(ctx, signal) {
   const next = services === void 0 ? { ...ctx, signal } : { ...ctx, signal, services: services(signal) };
   return withRuntime(Object.freeze(next), KIT_RUNTIMES.get(ctx), services);
 }
+function watchCallerReads(ctx, onRead) {
+  const watched = new Proxy(ctx, {
+    get(target, key, receiver) {
+      if (key === "principal" || key === "services" || key === "mcp") {
+        onRead(key);
+      }
+      return Reflect.get(target, key, receiver);
+    }
+  });
+  return withRuntime(watched, KIT_RUNTIMES.get(ctx), SERVICE_CALLERS.get(ctx));
+}
 
 export {
+  meetsLevel,
+  maxLevel,
+  levelsAtLeast,
+  serviceGrant,
+  SUBSCRIBE_LEVEL,
+  SUBSCRIBER_LEVELS,
+  strip,
+  referenced,
+  pointerToken,
+  inputKeys,
+  compileProjections,
+  projectedOutput,
+  pickKeys,
+  projectRow,
+  projectOutput,
+  wholeView,
+  readerView,
+  registerRuntime,
+  runtimeOf,
+  checkWhenDefined,
+  markGrantsEditor,
+  editsGrants,
+  handlerProblem,
+  checkWhenServed,
+  servedProblem,
+  isKitHandler,
+  checksRowsItself,
+  isRowChecked,
+  dependsOnCaller,
+  isCallerDependent,
+  narrowKinds,
+  checkKind,
   cancelledError,
   timeoutError,
   throwIfCancelled,
@@ -697,6 +1164,7 @@ export {
   kitRuntimeOf,
   NEVER_ABORTED,
   createContext,
-  withSignal
+  withSignal,
+  watchCallerReads
 };
-//# sourceMappingURL=chunk-2PWMUVC7.js.map
+//# sourceMappingURL=chunk-MBH6IDSM.js.map