okmodel 0.1.1 → 0.2.1

package/dist/shared/{rgs0st28.js → xrfnq5k8.js}

@@ -1,3 +1,7 @@
+import {
+  safetyInstalled,
+  runSafety
+} from "./a5sxz52y.js";
 import {
   isOperator,
   operatorName,
@@ -5,25 +9,131 @@ import {
 } from "./cn0n68ft.js";
 import {
   assertIdentifier2
-} from "./mkjmqjv4.js";
+} from "./nfzc5z0w.js";
 import {
   OkmError2,
-  safe2,
   throwNamed2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/runtime/plan.ts
-var FIND_OPTIONS = ["include", "limit", "orderBy", "select", "where"];
-var ONE_OPTIONS = ["include", "orderBy", "select", "where"];
-var FILTER_OPTIONS = ["where"];
+var activeScope;
+var activeView;
+function withRowFilters(scope, view, fn) {
+  const previousScope = activeScope;
+  const previousView = activeView;
+  activeScope = scope;
+  activeView = view;
+  try {
+    return fn();
+  } finally {
+    activeScope = previousScope;
+    activeView = previousView;
+  }
+}
+var archiveInspect;
+function installArchiveInspect(fn) {
+  archiveInspect = fn;
+}
+function archiveRules(model, view) {
+  return archiveInspect?.(model, view);
+}
+var FIND_OPTIONS = [
+  "include",
+  "limit",
+  "orderBy",
+  "select",
+  "signal",
+  "timeout",
+  "where"
+];
+var ONE_OPTIONS = ["include", "orderBy", "select", "signal", "timeout", "where"];
+var FILTER_OPTIONS = ["signal", "timeout", "where"];
+function readOptionNames(op) {
+  if (op === "find")
+    return FIND_OPTIONS;
+  if (op === "one")
+    return ONE_OPTIONS;
+  return FILTER_OPTIONS;
+}
 var BASE_RULES = [
   { rule: "parameterised", contribution: "planner", provenance: "planner" },
   { rule: "allowlisted", contribution: "catalog", provenance: "catalog" },
   { rule: "identifier", contribution: "catalog", provenance: "catalog" }
 ];
 var indexesOf = new WeakMap;
-function verifyRead(rules) {}
+var operatorEmit;
+function installOperatorSql(emit) {
+  operatorEmit = emit;
+}
+function readNeedsOperatorSql(schema, call) {
+  if (operatorEmit !== undefined)
+    return false;
+  const table = indexes(schema).get(call.table);
+  return table !== undefined && needsOperatorSql(table, call.where);
+}
+function emitRelationFrom(schema, relation, child, sink, parent, alias, depth) {
+  if (relation.through !== undefined) {
+    const planner = { join: emitJoin, where: emitWhere, indexes, quote };
+    relation.through.emit(planner, schema, relation, child, sink, parent, alias, depth);
+    return;
+  }
+  sink.text(quote(child.model.sql));
+  sink.text(" ");
+  sink.text(alias);
+  sink.text(" where ");
+  emitJoin(sink, parent, alias, relation);
+}
+var SYNC_OPERATORS = ",lt,lte,gt,gte,between,inList,notIn,";
+var TEXT_OPERATORS = ",startsWith,endsWith,contains,like,ilike,";
+function needsOperatorSql(table, value, key) {
+  if (isOperator(value)) {
+    const name = operatorName(value);
+    if (name === "or" || name === "and") {
+      const branches = operatorValue(value);
+      return Array.isArray(branches) && branches.some((branch) => needsOperatorSql(table, branch));
+    }
+    if (name === "not" || name === "eq")
+      return needsOperatorSql(table, operatorValue(value), key);
+    if (TEXT_OPERATORS.includes(`,${name},`)) {
+      const column = key === undefined ? undefined : table.columns.get(key);
+      return column !== undefined && !isTextColumn(column.dataType);
+    }
+    return !SYNC_OPERATORS.includes(`,${name},`);
+  }
+  if (Array.isArray(value))
+    return value.some((item) => needsOperatorSql(table, item, key));
+  if (!isRecord(value))
+    return false;
+  for (const field of Object.keys(value)) {
+    if (needsOperatorSql(table, value[field], field))
+      return true;
+  }
+  return false;
+}
+function isTextColumn(dataType) {
+  return dataType === "text" || dataType === "citext" || dataType.startsWith("varchar(") || dataType.startsWith("char(") || dataType.startsWith("character");
+}
+function emitLazy(column, ref, name, value, sink) {
+  const emit = operatorEmit;
+  if (emit === undefined) {
+    fail("OKM1121", `Operator ${name} on ${column.field} is not loaded.`);
+  }
+  emit(column, ref, name, value, sink);
+}
+function verifyRead(schema, call) {
+  if (!safetyInstalled())
+    return;
+  const source = schema.model[call.table]?.source;
+  const hatches = [];
+  if (call.all !== undefined)
+    hatches.push({ name: "all", reason: call.all });
+  if (call.scope !== undefined && "unscoped" in call.scope) {
+    hatches.push({ name: "unscoped", reason: call.scope.unscoped });
+  }
+  runSafety(appliedRules(call, source), hatches.length === 0 ? undefined : hatches);
+}
 function bindCall(schema, call, hooks) {
+  verifyRead(schema, call);
   const params = [];
   const marks = [];
   const sink = {
@@ -36,7 +146,6 @@ function bindCall(schema, call, hooks) {
     }
   };
   emit(schema, call, sink, undefined, hooks);
-  verifyRead(BASE_RULES);
   return { key: marks.join(""), params };
 }
 function compileCall(schema, call, key, hooks) {
@@ -96,8 +205,15 @@ function logicalIntent(call) {
     all: call.all
   };
 }
-function appliedRules(call) {
-  const rules = [...BASE_RULES];
+function appliedRules(call, source) {
+  const rules = [];
+  for (const rule of BASE_RULES) {
+    if (source !== undefined && rule.contribution === "catalog") {
+      rules.push({ ...rule, source });
+    } else {
+      rules.push(rule);
+    }
+  }
   if (call.where !== undefined) {
     rules.push({ rule: "filter", contribution: "caller", provenance: "caller" });
   }
@@ -108,13 +224,37 @@ function appliedRules(call) {
       provenance: "caller"
     });
   }
+  if (call.tenancyRules !== undefined) {
+    for (const rule of call.tenancyRules)
+      rules.push(rule);
+  }
+  if (call.ruleLines !== undefined) {
+    for (const rule of call.ruleLines)
+      rules.push(rule);
+  }
   return rules;
 }
 function emit(schema, call, sink, outputs, hooks) {
+  const previousScope = activeScope;
+  const previousView = activeView;
+  activeScope = call.scope;
+  activeView = call.archive;
+  try {
+    emitRead(schema, call, sink, outputs, hooks);
+  } finally {
+    activeScope = previousScope;
+    activeView = previousView;
+  }
+}
+function emitRead(schema, call, sink, outputs, hooks) {
   const table = indexes(schema).get(call.table);
   if (table === undefined) {
     throwNamed2("OKM1120", call.table, [...indexes(schema).keys()], `Table ${call.table} is not in the schema. Accepted names: ${list([...indexes(schema).keys()])}.`);
   }
+  if (call.build !== undefined) {
+    call.build(schema, table, sink, outputs, call);
+    return;
+  }
   rejectOptions(call);
   const selected = selectedColumns(table, call.select);
   sink.mark(`${call.op}|${call.table}|`);
@@ -169,9 +309,10 @@ function emit(schema, call, sink, outputs, hooks) {
       continue;
     hooks?.join(schema, include, sink, "t", `i${String(index)}`, 0);
   }
-  emitWhere(schema, table, call.where, sink, "t", 0);
+  emitWhere(schema, table, call.where, sink, "t", 0, false, call.after);
   emitOrder(table, call.orderBy, sink, "t");
   emitLimit(call, sink);
+  call.tail?.(sink);
 }
 function emitJoin(sink, parent, child, relation) {
   for (let index = 0;index < relation.local.length; index += 1) {
@@ -190,26 +331,56 @@ function emitJoin(sink, parent, child, relation) {
     sink.text(quote(local));
   }
 }
-function emitWhere(schema, table, where, sink, alias, depth, appended = false) {
-  if (where === undefined)
-    return;
-  if (isOperator(where) && operatorName(where) === "or") {
-    sink.text(appended ? " and " : " where ");
-    emitOr(schema, table, operatorValue(where), sink, alias, depth);
-    return;
+function holdArchive(table, sink, alias, appended) {
+  const archive = table.model.archive;
+  if (archive === undefined || activeView === "with")
+    return false;
+  sink.text(appended ? " and " : " where ");
+  sink.text(alias);
+  sink.text(".");
+  sink.text(quote(archive.at));
+  sink.text(activeView === "only" ? " is not null" : " is null");
+  sink.mark(activeView === "only" ? "archived|" : "active|");
+  return true;
+}
+function emitWhere(schema, table, where, sink, alias, depth, appended = false, extra) {
+  const held = schema.tenancy?.predicate({
+    table: table.model.name,
+    fieldSql: (field) => table.columns.get(field)?.sql,
+    encode: table.columns.get(schema.tenancy?.key ?? "")?.encode,
+    alias,
+    appended,
+    scope: activeScope,
+    sink
+  }) === true;
+  const archived = holdArchive(table, sink, alias, appended || held);
+  let started = appended || held || archived;
+  if (extra !== undefined) {
+    sink.text(started ? " and (" : " where (");
+    extra(sink, alias);
+    sink.text(")");
+    started = true;
   }
-  if (!isRecord(where)) {
-    fail("OKM1121", "where must be an object of fields. Wrap an object value with eq.");
+  for (const part of isOperator(where) && operatorName(where) === "and" ? operatorValue(where) : [where]) {
+    if (part === undefined)
+      continue;
+    const joined = isOperator(part);
+    if (!joined && !isRecord(part))
+      fail("OKM1121", WHERE_FIELDS);
+    if (!joined && Object.keys(part).length === 0)
+      continue;
+    sink.text(started ? " and " : " where ");
+    started = true;
+    if (joined && operatorName(part) === "or")
+      emitOr(schema, table, operatorValue(part), sink, alias, depth);
+    else
+      emitAnd(schema, table, part, sink, alias, depth);
   }
-  const keys = Object.keys(where);
-  if (keys.length === 0)
-    return;
-  sink.text(appended ? " and " : " where ");
-  emitAnd(schema, table, where, sink, alias, depth);
 }
+var WHERE_FIELDS = "where must be an object of fields. Wrap an object value with eq.";
 function emitAnd(schema, table, where, sink, alias, depth) {
   if (!isRecord(where)) {
-    fail("OKM1121", "where must be an object of fields. Wrap an object value with eq.");
+    fail("OKM1121", WHERE_FIELDS);
   }
   const keys = Object.keys(where);
   let wrote = false;
@@ -231,6 +402,7 @@ function emitPredicate(schema, table, key, value, sink, alias, depth) {
     emitRelationFilter(schema, relation, value, sink, alias, depth);
     return;
   }
+  schema.tenancy?.guard(table.model.name, key, "where");
   const column = table.columns.get(key);
   if (column === undefined) {
     throwNamed2("OKM1120", key, table.names, `Field ${key} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
@@ -238,7 +410,7 @@ function emitPredicate(schema, table, key, value, sink, alias, depth) {
   sink.mark(`w:${key}`);
   emitOperand(schema, table, column, value, sink, alias, depth);
 }
-function emitOperand(schema, table, column, value, sink, alias, depth) {
+function emitOperand(schema, table, column, value, sink, alias, depth, wrapped = false) {
   const ref = `${alias}.${quote(column.sql)}`;
   if (isOperator(value)) {
     emitOperator(schema, table, column, ref, operatorName(value), operatorValue(value), sink, alias, depth);
@@ -250,9 +422,8 @@ function emitOperand(schema, table, column, value, sink, alias, depth) {
     sink.text(" is null");
     return;
   }
-  if (typeof value === "object") {
-    fail("OKM1121", `Field ${column.field} received an object. Wrap it with eq. eq is the equality form for json and jsonb.`);
-  }
+  if (typeof value === "object")
+    takeObject(column, value, !wrapped);
   sink.mark(":eq");
   sink.text(ref);
   sink.text(" = ");
@@ -272,7 +443,7 @@ function emitOperator(schema, table, column, ref, name, value, sink, alias, dept
     return;
   }
   if (name === "eq") {
-    emitOperand(schema, table, column, value, sink, alias, depth);
+    emitOperand(schema, table, column, value, sink, alias, depth, true);
     return;
   }
   if (name === "lt" || name === "lte" || name === "gt" || name === "gte") {
@@ -296,26 +467,25 @@ function emitOperator(schema, table, column, ref, name, value, sink, alias, dept
     emitIn(column, ref, name, value, sink);
     return;
   }
-  if (name === "startsWith" || name === "contains" || name === "endsWith") {
+  if (TEXT_OPERATORS.includes(`,${name},`) && isTextColumn(column.dataType)) {
     if (typeof value !== "string") {
       fail("OKM1121", `${name} on ${column.field} needs a string.`);
     }
     sink.text(ref);
+    if (name === "like" || name === "ilike") {
+      sink.text(name === "like" ? " like " : " ilike ");
+      sink.param(value);
+      return;
+    }
     sink.text(" like ");
-    sink.param(literalPattern(value, name));
-    sink.text(" escape E'\\\\'");
-    return;
-  }
-  if (name === "like" || name === "ilike") {
-    if (typeof value !== "string") {
+    if (name !== "startsWith" && name !== "endsWith" && name !== "contains") {
       fail("OKM1121", `${name} on ${column.field} needs a string.`);
     }
-    sink.text(ref);
-    sink.text(name === "like" ? " like " : " ilike ");
-    sink.param(value);
+    sink.param(literalPattern(value, name));
+    sink.text(" escape E'\\\\'");
     return;
   }
-  fail("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
+  emitLazy(column, ref, name, value, sink);
 }
 function emitNot(schema, table, column, ref, value, sink, alias, depth) {
   if (value === null) {
@@ -332,7 +502,7 @@ function emitNot(schema, table, column, ref, value, sink, alias, depth) {
     }
   }
   sink.text("not (");
-  emitOperand(schema, table, column, value, sink, alias, depth);
+  emitOperand(schema, table, column, value, sink, alias, depth, true);
   sink.text(")");
 }
 function emitIn(column, ref, name, value, sink) {
@@ -402,13 +572,10 @@ function emitRelationFilter(schema, relation, value, sink, alias, depth) {
   if (name === "none" || name === "every")
     sink.text("not ");
   sink.text("exists (select 1 from ");
-  sink.text(quote(child.model.sql));
-  sink.text(" ");
-  sink.text(childAlias);
-  sink.text(" where ");
-  emitJoin(sink, alias, childAlias, relation);
+  emitRelationFrom(schema, relation, child, sink, alias, childAlias, depth);
   const inner = operatorValue(value);
   if (name === "every") {
+    emitWhere(schema, child, undefined, sink, childAlias, depth + 1, true);
     sink.text(" and not (");
     emitAnd(schema, child, inner ?? {}, sink, childAlias, depth + 1);
     sink.text(")");
@@ -540,8 +707,7 @@ function parseOrder(field, value) {
   fail("OKM1120", `orderBy ${field} must be asc or desc.`);
 }
 function rejectOptions(call) {
-  const record = call;
-  const accepted = call.op === "find" ? FIND_OPTIONS : call.op === "one" ? ONE_OPTIONS : FILTER_OPTIONS;
+  const accepted = readOptionNames(call.op);
   const present = {};
   if (call.where !== undefined)
     present.where = call.where;
@@ -569,11 +735,18 @@ function readLimit(value) {
   return value;
 }
 function requireValue(column, value) {
-  if (value === undefined || value === null || typeof value === "object") {
-    fail("OKM1121", `Field ${column.field} needs a value. Wrap an object with eq.`);
+  if (value === undefined || value === null) {
+    fail("OKM1121", `Field ${column.field} needs a value.`);
   }
+  if (typeof value === "object")
+    takeObject(column, value);
   return value;
 }
+function takeObject(column, value, bare = false) {
+  if (bare || !column.accepts?.includes({}.toString.call(value).slice(8, -1))) {
+    fail("OKM1121", `Field ${column.field} rejects that object.`);
+  }
+}
 function projectExpr(sql, dataType) {
   if (dataType === "timestamptz" || dataType === "timestamp")
     return jsonExpr(sql, dataType);
@@ -630,8 +803,9 @@ function indexes(schema) {
     }
     names.sort();
     const relations = new Map;
-    for (const relation of model.relations)
+    for (const relation of model.relations) {
       relations.set(relation.name, relation);
+    }
     built.set(model.name, { model, columns, relations, names });
   }
   indexesOf.set(schema, built);
@@ -661,9 +835,16 @@ function list(names) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !isOperator(value);
 }
+var FAIL_FIX = {
+  OKM1121: "Use eq for an object value, or has, none, or every for a relation.",
+  OKM1101: "Pass limit, or call .all(reason)."
+};
+function registerFailFix(code, summary) {
+  FAIL_FIX[code] = summary;
+}
 function fail(code, message) {
-  const fix = code === "OKM1121" ? { summary: "Use eq for an object value, or has, none, or every for a relation." } : code === "OKM1101" ? { summary: "Pass limit, or call .all(reason)." } : code === "OKM1102" ? { summary: "Pass where, or call .all(reason) to match every row." } : code === "OKM1104" ? { summary: "Set on to the columns of a unique constraint or the primary key." } : code === "OKM1105" ? { summary: "Pass limit on the include, or call .all(reason)." } : code === "OKM1190" ? { summary: "Remove the guarded field. Input cannot set it." } : undefined;
-  throw new OkmError2(code, message, fix === undefined ? undefined : { fix });
+  const summary = FAIL_FIX[code];
+  throw new OkmError2(code, message, summary === undefined ? undefined : { fix: { summary } });
 }
 function plain(value) {
   if (isOperator(value)) {
@@ -685,382 +866,4 @@ function hasMany(include) {
   return Object.keys(include).length > 0;
 }
 
-// src/runtime/client.ts
-var PLAN_LIMIT = 64;
-var SINGLE_ENDPOINT = {
-  endpoint: "primary",
-  role: "primary",
-  reason: "single-endpoint"
-};
-function createClient(schema, pool, options) {
-  const connected = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
-    ...options.catalog !== undefined ? { catalog: options.catalog } : {},
-    ...options.catalogDir !== undefined ? { catalogDir: options.catalogDir } : {}
-  });
-  const session = {
-    schema,
-    pool,
-    ownsPool: options.ownsPool,
-    http: options.http,
-    includeValues: options.includeValues === true,
-    logger: options.logger,
-    connected,
-    cache: new Map
-  };
-  const tables = {};
-  for (const name of Object.keys(schema.model)) {
-    tables[name] = tableApi(session, name);
-  }
-  let closing;
-  const client = {
-    ...tables,
-    table(name) {
-      const found = tables[name];
-      if (found !== undefined)
-        return found;
-      try {
-        throwNamed2("OKM1120", name, Object.keys(tables), `Table ${name} is not in the schema. Accepted names: ${Object.keys(tables).join(", ")}.`);
-      } catch (error) {
-        if (error instanceof OkmError2)
-          throw attachHttp(session.http, error);
-        throw error;
-      }
-    },
-    close() {
-      if (!options.ownsPool)
-        return Promise.resolve();
-      closing ??= pool.close();
-      return closing;
-    },
-    connected
-  };
-  attachAsyncDispose(client, () => client.close());
-  return client;
-}
-function attachAsyncDispose(client, close) {
-  const symbol = Symbol.asyncDispose;
-  if (typeof symbol !== "symbol")
-    return;
-  Object.defineProperty(client, symbol, {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: () => close()
-  });
-}
-function tableApi(session, table) {
-  return {
-    find(options = {}) {
-      return start(session, "find", table, options, {});
-    },
-    one(options = {}) {
-      return start(session, "one", table, options, {});
-    },
-    count(options = {}) {
-      return start(session, "count", table, options, {});
-    },
-    exists(options = {}) {
-      return start(session, "exists", table, options, {});
-    },
-    insert(data, options = {}) {
-      return writeHandle(session, "insert", table, data, options, {});
-    },
-    update(target, options = {}) {
-      return writeHandle(session, "update", table, target, options, {});
-    },
-    delete(target, options = {}) {
-      return writeHandle(session, "delete", table, target, options, {});
-    }
-  };
-}
-var writers;
-function loadWrite() {
-  writers ??= import("./x5x59srr.js");
-  return writers;
-}
-function writeHandle(session, op, table, input, options, mods) {
-  let pending;
-  const run = () => {
-    pending ??= runWrite(session, op, table, input, options, mods);
-    return pending;
-  };
-  const self = {
-    then(onFulfilled, onRejected) {
-      return run().then(onFulfilled, onRejected);
-    },
-    catch(onRejected) {
-      return self.then(undefined, onRejected);
-    },
-    finally(fn) {
-      return self.then((value) => {
-        fn();
-        return value;
-      }, (error) => {
-        fn();
-        throw error;
-      });
-    },
-    safe() {
-      return safe2(run());
-    },
-    sql() {
-      return loadWrite().then((mod) => mod.explainWrite(session.schema, op, table, input, options, mods));
-    },
-    expect(count) {
-      return writeHandle(session, op, table, input, options, { ...mods, expect: count });
-    },
-    all(reason) {
-      return writeHandle(session, op, table, input, options, { ...mods, all: reason });
-    }
-  };
-  return self;
-}
-async function runWrite(session, op, table, input, options, mods) {
-  await session.connected;
-  const mod = await loadWrite();
-  try {
-    return await mod.executeWrite({ schema: session.schema, pool: session.pool }, op, table, input, options, mods);
-  } catch (error) {
-    throw logged(session, await mapError(session, error));
-  }
-}
-function start(session, op, table, options, mods) {
-  const call = readCall(op, table, options, mods.all);
-  let prepared;
-  const prepare = async () => {
-    if (prepared !== undefined)
-      return prepared;
-    const hooks = await hooksFor(call);
-    const bound = bindCall(session.schema, call, hooks);
-    let plan = session.cache.get(bound.key);
-    if (plan === undefined) {
-      plan = compileCall(session.schema, call, bound.key, hooks);
-      if (session.cache.size >= PLAN_LIMIT) {
-        const oldest = session.cache.keys().next().value;
-        if (oldest !== undefined)
-          session.cache.delete(oldest);
-      }
-      session.cache.set(bound.key, plan);
-    }
-    prepared = { plan, params: bound.params };
-    return prepared;
-  };
-  const run = async () => {
-    await session.connected;
-    const { plan, params } = await prepare();
-    try {
-      const result = await session.pool.execute(plan.text, params, callOptions(mods));
-      const value = plan.outputs.includes.length === 0 ? decodeResult(plan, result.rows, table) : (await import("./hadrfb9h.js")).decodeIncluded(plan, result.rows, table);
-      if (mods.required === true && value === null) {
-        throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
-      }
-      return value;
-    } catch (error) {
-      throw logged(session, await mapError(session, error));
-    }
-  };
-  let pending;
-  const once = () => {
-    pending ??= run();
-    return pending;
-  };
-  const self = {
-    then(onFulfilled, onRejected) {
-      return once().then(onFulfilled, onRejected);
-    },
-    catch(onRejected) {
-      return this.then(undefined, onRejected);
-    },
-    finally(fn) {
-      return this.then((value) => {
-        fn();
-        return value;
-      }, (error) => {
-        fn();
-        throw error;
-      });
-    },
-    inspect() {
-      if (call.include === undefined && prepared !== undefined) {
-        return inspection(prepared.plan, prepared.params, call);
-      }
-      if (call.include === undefined) {
-        const bound = bindNow(session.schema, call);
-        prepared = bound;
-        return inspection(bound.plan, bound.params, call);
-      }
-      return prepare().then(({ plan, params }) => inspection(plan, params, call));
-    },
-    sql() {
-      if (call.include === undefined && prepared !== undefined) {
-        return { text: prepared.plan.text, params: prepared.params };
-      }
-      if (call.include === undefined) {
-        const { plan, params } = bindNow(session.schema, call);
-        prepared = { plan, params };
-        return { text: plan.text, params };
-      }
-      return prepare().then(({ plan, params }) => ({ text: plan.text, params }));
-    },
-    safe() {
-      return safe2(once());
-    },
-    all(reason) {
-      return start(session, op, table, options, { ...mods, all: reason });
-    },
-    required() {
-      return start(session, op, table, options, { ...mods, required: true });
-    },
-    stream() {
-      return streamRows(session, call, prepare);
-    }
-  };
-  return self;
-}
-async function* streamRows(session, call, prepare) {
-  await session.connected;
-  if (session.pool.capabilities.stream !== true || session.pool.stream === undefined) {
-    throw logged(session, new OkmError2("OKM1111", "stream needs a driver with stream: true. This driver does not have it.", withHttp(session.http, {
-      fix: { summary: "Use a driver that sets stream, or read with find." }
-    })));
-  }
-  const { plan, params } = await prepare();
-  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./hadrfb9h.js")).decodeIncluded;
-  for await (const chunk of session.pool.stream(plan.text, params)) {
-    const decoded = decode(plan, chunk, call.table);
-    if (!Array.isArray(decoded))
-      continue;
-    for (const row of decoded)
-      yield row;
-  }
-}
-function readCall(op, table, options, all) {
-  const record = options;
-  const accepted = op === "find" ? ["include", "limit", "orderBy", "select", "where"] : op === "one" ? ["include", "orderBy", "select", "where"] : ["where"];
-  for (const key of Object.keys(record)) {
-    if (!accepted.includes(key)) {
-      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${op}. Accepted options: ${accepted.join(", ")}.`);
-    }
-  }
-  return {
-    op,
-    table,
-    ...record.where !== undefined ? { where: record.where } : {},
-    ...record.select !== undefined ? { select: record.select } : {},
-    ...record.orderBy !== undefined ? { orderBy: record.orderBy } : {},
-    ...record.limit !== undefined ? { limit: record.limit } : {},
-    ...record.include !== undefined ? { include: record.include } : {},
-    ...all !== undefined ? { all } : {}
-  };
-}
-async function checkServer(pool, schema, http, requireMeta, options, source) {
-  let rows;
-  try {
-    const result = await pool.execute(SERVER_CHECK, undefined, options);
-    rows = result.rows;
-  } catch (error) {
-    const { mapPostgresError } = await import("./zhc5vmgf.js");
-    throw mapPostgresError(error, mapOptions(http, false));
-  }
-  const version = rows[0]?.[1];
-  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
-    throw new OkmError2("OKM1801", "The server is not PostgreSQL. The schema dialect is postgres.", withHttp(http, {
-      fix: { summary: "Open the schema with the Postgres driver that matches it." }
-    }));
-  }
-  const recorded = rows[0]?.[2];
-  if (recorded === null || recorded === undefined || recorded.length === 0) {
-    if (requireMeta) {
-      throw new OkmError2("OKM1520", "okm_meta has no catalog hash.", withHttp(http, {
-        fix: {
-          summary: "Apply migrations so okm_meta records the catalog, or omit requireMeta to adopt this database."
-        }
-      }));
-    }
-  } else {
-    const { assertCompatible } = await import("./qk3hxfja.js");
-    try {
-      await assertCompatible(pool, schema, recorded, source, options);
-    } catch (error) {
-      if (error instanceof OkmError2)
-        throw attachHttp(http, error);
-      throw error;
-    }
-  }
-  const requires = schema.requires?.postgres;
-  if (requires === undefined)
-    return;
-  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
-  const match = /^>=(\d+)$/.exec(requires.trim());
-  const need = match?.[1] === undefined ? undefined : Number(match[1]);
-  if (need === undefined || major < need) {
-    throw new OkmError2("OKM1802", `The server is PostgreSQL ${String(major)}. schema({ requires }) asks for ${requires}.`, withHttp(http, {
-      fix: { summary: "Upgrade the server, or lower requires to a version the server meets." }
-    }));
-  }
-}
-async function mapError(session, error) {
-  if (error instanceof OkmError2) {
-    return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
-  }
-  const { mapPostgresError } = await import("./zhc5vmgf.js");
-  return mapPostgresError(error, mapOptions(session.http, session.includeValues));
-}
-function errorFields(error) {
-  return {
-    kind: error.kind,
-    ...error.table !== undefined ? { table: error.table } : {},
-    ...error.columns.length > 0 ? { columns: error.columns } : {},
-    fix: error.fix
-  };
-}
-var includeHooks;
-function hooksFor(call) {
-  if (call.include === undefined)
-    return Promise.resolve(undefined);
-  includeHooks ??= import("./hadrfb9h.js").then((mod) => mod.includeHooks);
-  return includeHooks;
-}
-function bindNow(schema, call) {
-  const bound = bindCall(schema, call);
-  const plan = compileCall(schema, call, bound.key);
-  return { plan, params: bound.params };
-}
-function inspection(plan, params, call) {
-  return {
-    intent: logicalIntent(call),
-    rules: appliedRules(call),
-    plan: { strategy: "postgres:single-statement", statements: 1, fingerprint: plan.fingerprint },
-    sql: { text: plan.text, params },
-    routing: SINGLE_ENDPOINT
-  };
-}
-function withHttp(http, options) {
-  return http === undefined ? options : { ...options, http };
-}
-function attachHttp(http, error) {
-  if (http === undefined)
-    return error;
-  return new OkmError2(error.code, error.message, { ...errorFields(error), http });
-}
-function callOptions(input) {
-  if (input.signal === undefined && input.timeout === undefined)
-    return;
-  return {
-    ...input.signal !== undefined ? { signal: input.signal } : {},
-    ...input.timeout !== undefined ? { timeout: input.timeout } : {}
-  };
-}
-var SERVER_CHECK = "select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from okm_meta where id = ''head''', true, false, '')))[1]::text where to_regclass('okm_meta') is not null)";
-function mapOptions(http, includeValues) {
-  return {
-    ...http !== undefined ? { http } : {},
-    ...includeValues ? { includeValues: true } : {}
-  };
-}
-function logged(session, error) {
-  session.logger?.error?.({ code: error.code, summary: error.summary });
-  return error;
-}
-
-export { decodeResult, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, selectedColumns, rejectKeys, readLimit, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, fail, createClient };
+export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, emitRelationFrom, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, registerFailFix, fail };