okmodel 0.6.0 → 0.8.0

package/dist/shared/{f0f1n281.js → mkrn359n.js}

@@ -1,26 +1,27 @@
+import {
+  normaliseViewQuery,
+  viewObject,
+  materializedViewObject
+} from "./12z7aznj.js";
 import {
   cellText,
   VIEW_DEPENDENCIES,
   viewDependencyEdges,
   PUBLIC,
-  introspectSchema
-} from "./vjpnzwjz.js";
+  introspectSchema,
+  atomicBody
+} from "./p3xbdcvt.js";
 import {
   planMigration,
   sessionFailure,
   finishQuiet,
   assertDirectConnection,
   assertStableBackend
-} from "./ttmg09vd.js";
+} from "./dpc2r7rb.js";
 import {
   quoteIdent,
   createObjectSql
-} from "./9s0ypp87.js";
-import {
-  normaliseViewQuery,
-  viewObject,
-  materializedViewObject
-} from "./zy8r7qvz.js";
+} from "./sjk86yrx.js";
 import {
   catalog
 } from "./ywspezzx.js";
@@ -49,7 +50,8 @@ var VIEW_SHAPE = `
 `;
 async function sealViews(runner, source) {
   const views = source.objects.filter((object) => object.kind === "view" || object.kind === "materializedView");
-  if (views.length === 0)
+  const hasAtomic = source.objects.some((object) => object.kind === "function" && object.definition.atomic === true);
+  if (views.length === 0 && !hasAtomic)
     return source;
   await dropScratch(runner);
   await runner.query(`create schema ${quoteIdent(SCRATCH)}`);
@@ -65,12 +67,15 @@ async function sealViews(runner, source) {
       await runner.query(stubTable(object, source));
     }
     await createObjects(runner, source, "function");
+    const reprinted = await reprintAtomicBodies(runner, source);
+    if (views.length === 0)
+      return reprinted;
     await createViews(runner, views);
     const shapes = await runner.query(VIEW_SHAPE, [SCRATCH]);
     const deps = await runner.query(VIEW_DEPENDENCIES, [SCRATCH]);
     const edges = viewDependencyEdges(deps, PUBLIC, source.objects);
     const byName = new Map(shapes.map((row) => [cellText(row.name), row]));
-    const next = source.objects.map((object) => {
+    const next = reprinted.objects.map((object) => {
       if (object.kind !== "view" && object.kind !== "materializedView")
         return object;
       const row = byName.get(object.identity.name);
@@ -147,6 +152,40 @@ async function createObjects(runner, source, kind) {
       await runner.query(statement);
   }
 }
+var FUNCTION_DEFS = `
+  select pg_get_functiondef(p.oid) as definition
+  from pg_proc p
+  join pg_namespace n on n.oid = p.pronamespace
+  where n.nspname = $1 and p.prokind = 'f'
+  order by p.oid
+`;
+async function reprintAtomicBodies(runner, source) {
+  const created = source.objects.filter((object) => object.kind === "function");
+  if (!created.some((object) => object.definition.atomic === true))
+    return source;
+  const rows = await runner.query(FUNCTION_DEFS, [SCRATCH]);
+  if (rows.length !== created.length) {
+    throw new OkmError2("OKM1020", `Expected ${String(created.length)} functions in the scratch schema and found ${String(rows.length)}.`, { fix: { summary: "The function body has to run against the tables in this schema." } });
+  }
+  const bodies = new Map;
+  for (let index = 0;index < created.length; index += 1) {
+    const object = created[index];
+    if (object === undefined || object.definition.atomic !== true)
+      continue;
+    bodies.set(object, atomicBody(cellText(rows[index]?.definition)));
+  }
+  let changed = false;
+  const objects = source.objects.map((object) => {
+    if (object.kind !== "function")
+      return object;
+    const body = bodies.get(object);
+    if (body === undefined || body === object.definition.body)
+      return object;
+    changed = true;
+    return { ...object, definition: { ...object.definition, body } };
+  });
+  return changed ? catalog(objects) : source;
+}
 async function createViews(runner, views) {
   const pending = [...views];
   let last = "";
@@ -210,6 +249,12 @@ async function dropScratch(runner) {
     join pg_namespace n on n.oid = c.relnamespace
     where n.nspname = $1 and c.relkind in ('v', 'm', 'r')
   `, [SCRATCH]);
+  const routines = await runner.query(`
+    select p.proname as name, pg_get_function_identity_arguments(p.oid) as args
+    from pg_proc p
+    join pg_namespace n on n.oid = p.pronamespace
+    where n.nspname = $1
+  `, [SCRATCH]);
   const views = rows.filter((row) => cellText(row.kind) === "v" || cellText(row.kind) === "m");
   for (let pass = 0;pass < Math.max(views.length, 1); pass += 1) {
     for (const row of views) {
@@ -219,6 +264,10 @@ async function dropScratch(runner) {
       } catch {}
     }
   }
+  for (const row of routines) {
+    const args = cellText(row.args);
+    await runner.query(`drop function if exists ${quoteIdent(SCRATCH)}.${quoteIdent(cellText(row.name))}(${args})`);
+  }
   for (const row of rows) {
     if (cellText(row.kind) !== "r")
       continue;

package/dist/shared/{p248q79y.js → mnvjvqyp.js}

@@ -1,9 +1,9 @@
 import {
   serializeCatalog2
-} from "./qq3899ht.js";
+} from "./12z7aznj.js";
 import {
   roleExists
-} from "./knmes2kh.js";
+} from "./kj9d8maq.js";
 import {
   canonicalTypeName,
   createdRoleName,
@@ -16,24 +16,24 @@ import {
   planMigration,
   sessionFailure,
   assertTargetPolicy
-} from "./ttmg09vd.js";
+} from "./dpc2r7rb.js";
+import {
+  snakeCase
+} from "./gcefca6p.js";
 import {
   quoteIdent,
   qualify
-} from "./9s0ypp87.js";
-import {
-  alignExtensionVersions
-} from "./r3j8s5y0.js";
+} from "./sjk86yrx.js";
 import {
   catalog,
   isDomain
 } from "./ywspezzx.js";
-import {
-  snakeCase
-} from "./rpycarcr.js";
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
+import {
+  alignExtensionVersions
+} from "./r3j8s5y0.js";
 import {
   identityKey2,
   identityLabel2

package/dist/shared/{672t5vym.js → mss6ctgv.js}

@@ -3,10 +3,10 @@ import {
 } from "./cn0n68ft.js";
 
 // src/runtime/preset-stack.ts
-function stack(where, presets) {
+function stack2(where, presets) {
   if (presets === undefined || presets.length === 0)
     return where;
   return tag("and", where === undefined ? presets : [where, ...presets]);
 }
 
-export { stack };
+export { stack2 };

package/dist/shared/{4az561fn.js → mtw6jz76.js}

@@ -4,12 +4,9 @@ import {
   nextTransactionDepth,
   EMPTY_NOTICES,
   resultFrom
-} from "./cgbamx3e.js";
+} from "./ae4j5f42.js";
 
 // src/adapters/pg/session.ts
-function quoteIdent2(name) {
-  return `"${name.replaceAll('"', '""')}"`;
-}
 function noticeBuffer() {
   let notices;
   return {
@@ -63,7 +60,7 @@ class WireSession {
         return resultFrom(result, this.notices.since(start));
       }, (error) => {
         this.onLeave();
-        return driverErrors().then((errors) => Promise.reject(errors.mapDriverError(error)));
+        return driverErrors().then((errors) => Promise.reject(errors.mapDriverError(stampQuery(error, text))));
       });
     }
     return this.watched(pending, watch, start, text);
@@ -110,7 +107,7 @@ class WireSession {
       return resultFrom(result, this.notices.since(start));
     }, (error) => {
       this.finishWatched(pending, watch, onAbort);
-      return classify(error, watch);
+      return classify(stampQuery(error, text), watch);
     });
   }
   finishWatched(pending, watch, onAbort) {
@@ -119,22 +116,10 @@ class WireSession {
     watch.signal.removeEventListener("abort", onAbort);
   }
 }
-async function* cursorStream(run, text, params) {
-  const name = "okm_stream";
-  await run("BEGIN");
-  try {
-    await run(`DECLARE ${name} NO SCROLL CURSOR FOR ${text}`, params);
-    for (;; ) {
-      const chunk = await run(`FETCH 64 FROM ${name}`);
-      if (chunk.rows.length === 0)
-        break;
-      yield chunk.rows;
-    }
-  } finally {
-    await run("ROLLBACK").catch(() => {
-      return;
-    });
-  }
+function stampQuery(error, text) {
+  if (typeof error === "object" && error !== null && !("query" in error))
+    Reflect.set(error, "query", text);
+  return error;
 }
 async function classify(error, watch) {
   const errors = await driverErrors();
@@ -151,4 +136,4 @@ async function classify(error, watch) {
   return Promise.reject(errors.mapDriverError(error));
 }
 
-export { quoteIdent2, noticeBuffer, WireSession, cursorStream };
+export { noticeBuffer, WireSession };

package/dist/shared/n05z9nwz.js

@@ -0,0 +1,313 @@
+import {
+  queryHandle,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./bah9nbg3.js";
+import {
+  emitWhere,
+  emitOrder,
+  refuseHidden,
+  rejectKeys,
+  readLimit,
+  projectExpr,
+  cell,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail2
+} from "./kgwp4jdd.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/aggregate.ts
+var BUCKET = Symbol.for("okmodel.bucket");
+var bucketChunk;
+function loadBucketGroup() {
+  return bucketChunk ??= import("./th3be82n.js");
+}
+var OPTIONS = [
+  "where",
+  "groupBy",
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "orderBy",
+  "limit",
+  "route",
+  "signal",
+  "timeout"
+];
+var NUMERIC = /^(smallint|integer|bigint|real|double precision|numeric|decimal)\b/;
+var AS_NUMBER = (wire) => Number(wire);
+var AS_TEXT = (wire) => wire;
+var UNORDERED = /^(json|jsonb|bytea|point|line|tsvector)\b|\[\]$/;
+var FUNCTIONS = [
+  { option: "sum", tag: "s", numeric: true },
+  { option: "avg", tag: "a", numeric: true },
+  { option: "min", tag: "n", numeric: false },
+  { option: "max", tag: "x", numeric: false }
+];
+function build(session, table, options, mods, view) {
+  try {
+    if (seesBucket(options))
+      return bucketHandle(session, table, options, mods, view);
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
+  }
+}
+function bucketHandle(session, table, options, mods, view) {
+  const open = () => loadBucketGroup().then((mod) => {
+    try {
+      return { it: plan(session, table, options, mods, view, mod) };
+    } catch (error) {
+      throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
+    }
+  });
+  return queryHandle(() => open().then((box) => box.it), {
+    inspect: () => open().then((box) => box.it.inspect()),
+    sql: () => open().then((box) => box.it.sql()),
+    all: (reason) => build(session, table, options, { ...mods, all: reason }, view)
+  });
+}
+function seesBucket(options) {
+  if (!isRecord(options))
+    return false;
+  const groupBy = options.groupBy;
+  if (!Array.isArray(groupBy))
+    return false;
+  for (const item of groupBy) {
+    if (typeof item === "object" && item !== null && BUCKET in item)
+      return true;
+  }
+  return false;
+}
+function plan(session, table, options, mods, view, buckets) {
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, OPTIONS, "aggregate");
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
+  const spec = parse(indexed, record, buckets);
+  if (spec.groups.length > 0 && record.limit === undefined && mods.all === undefined) {
+    fail2("OKM1101", "aggregate() with groupBy needs a limit, or .all(reason) for every group.");
+  }
+  const names = groupNames(spec.groups);
+  const orderBy = record.orderBy;
+  if (orderBy !== undefined) {
+    if (!isRecord(orderBy))
+      fail2("OKM1120", "orderBy must be an object of fields.");
+    for (const field of Object.keys(orderBy)) {
+      if (!names.includes(field)) {
+        const column = indexed.columns.get(field);
+        if (column !== undefined)
+          refuseHidden(column);
+        throwNamed2("OKM1120", field, names, `aggregate() orders by a groupBy field. Accepted names: ${list(names)}.`);
+      }
+    }
+  }
+  if (record.limit !== undefined)
+    readLimit(record.limit);
+  const base = readCall("find", table, {
+    where: record.where,
+    orderBy,
+    limit: record.limit,
+    signal: record.signal,
+    timeout: record.timeout,
+    route: record.route
+  }, mods.all, session.scope, session.schema.model[table], session.schema, view);
+  const call = { ...base, op: "aggregate", build: statement(spec, buckets) };
+  return readHandle(session, table, call, mods, (compiled, rows) => decode(compiled, rows));
+}
+function parse(table, record, buckets) {
+  const grouped = readGroups(table, record.groupBy, buckets);
+  const count = record.count === true;
+  if (record.count !== undefined && typeof record.count !== "boolean") {
+    fail2("OKM1120", "count is true when you want a row count.");
+  }
+  const calls = [];
+  for (const { option, tag, numeric } of FUNCTIONS) {
+    for (const column of columns(table, record[option], option)) {
+      const fits = numeric ? NUMERIC.test(column.dataType) : !UNORDERED.test(column.dataType);
+      if (!fits) {
+        fail2("OKM1124", `${option} does not apply to ${column.dataType} column ${column.field}. ${numeric ? "sum and avg take integer, real, and numeric columns." : "min and max need an ordered type."}`);
+      }
+      calls.push({ option, tag, column, decode: numeric ? sumDecode(column) : column.decode });
+    }
+  }
+  if (!count && calls.length === 0 && grouped.groups.length === 0) {
+    fail2("OKM1120", "aggregate() needs count, sum, avg, min, max, or groupBy.");
+  }
+  return { groups: grouped.groups, bucketed: grouped.bucketed, count, calls };
+}
+function sumDecode(column) {
+  const kind = typeof (column.decode?.("0") ?? "");
+  if (kind === "string")
+    return AS_TEXT;
+  if (kind === "number")
+    return AS_NUMBER;
+  return fail2("OKM1124", `sum and avg need a column whose value is a number or a string. ${column.field} reads as ${kind}.`);
+}
+function columns(table, value, option) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    fail2("OKM1120", `${option} must be a list of field names.`);
+  const out = [];
+  for (const name of value) {
+    const column = typeof name === "string" ? table.columns.get(name) : undefined;
+    if (typeof name !== "string" || column === undefined) {
+      throwNamed2("OKM1120", String(name), table.names, `Field ${String(name)} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden, so ${option} cannot read it.`);
+    }
+    out.push(column);
+  }
+  return out;
+}
+function groupNames(groups) {
+  const names = [];
+  for (const group of groups)
+    names.push(group.kind === "field" ? group.column.field : group.as);
+  return names;
+}
+function readGroups(table, value, buckets) {
+  if (value === undefined)
+    return { groups: [], bucketed: false };
+  if (!Array.isArray(value))
+    fail2("OKM1120", "groupBy must be a list of field names.");
+  const fields = new Set;
+  const aliases = new Set;
+  const groups = [];
+  let bucketed = false;
+  for (const item of value) {
+    if (typeof item === "object" && item !== null && BUCKET in item) {
+      if (buckets === undefined)
+        fail2("OKM1120", "bucket group");
+      groups.push(buckets.readBucket(table, item, fields, aliases));
+      bucketed = true;
+      continue;
+    }
+    const column = typeof item === "string" ? table.columns.get(item) : undefined;
+    if (typeof item !== "string" || column === undefined) {
+      throwNamed2("OKM1120", String(item), table.names, `Field ${String(item)} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (column.hidden) {
+      fail2("OKM1120", `Field ${column.field} is hidden, so groupBy cannot read it.`);
+    }
+    if (aliases.has(column.field)) {
+      fail2("OKM1120", `group field ${column.field} clashes with a bucket as.`);
+    }
+    fields.add(column.field);
+    groups.push({ kind: "field", column });
+  }
+  return { groups, bucketed };
+}
+function statement(spec, buckets) {
+  return (schema, table, sink, outputs, call) => {
+    sink.mark(`aggregate|${table.model.name}|g:${groupMark(spec.groups)}|c:${String(spec.count)}|${spec.calls.map((item) => `${item.tag}:${item.column.field}`).join(",")}|`);
+    sink.text("select ");
+    const wrote = { at: 0 };
+    for (const group of spec.groups) {
+      if (group.kind === "field") {
+        put(sink, outputs, wrote, projectExpr(`t.${quote(group.column.sql)}`, group.column.dataType), {
+          key: `g:${group.column.field}`,
+          decode: group.column.decode
+        });
+      } else {
+        if (buckets === undefined)
+          fail2("OKM1120", "bucket group");
+        buckets.writeBucket(sink, outputs, wrote, group);
+      }
+    }
+    if (spec.count)
+      put(sink, outputs, wrote, "count(*)::text", { key: "c:", decode: undefined });
+    for (const item of spec.calls) {
+      const ref = `t.${quote(item.column.sql)}`;
+      const expr = item.option === "sum" || item.option === "avg" ? `${item.option}(${ref})::text` : projectExpr(`${item.option}(${ref})`, item.column.dataType);
+      put(sink, outputs, wrote, expr, {
+        key: `${item.tag}:${item.column.field}`,
+        decode: item.decode
+      });
+    }
+    sink.text(" from ");
+    sink.text(quote(table.model.sql));
+    sink.text(" t");
+    emitWhere(schema, table, call.where, sink, "t", 0);
+    if (spec.groups.length > 0) {
+      sink.text(" group by ");
+      if (spec.bucketed) {
+        if (buckets === undefined)
+          fail2("OKM1120", "bucket group");
+        buckets.writeGrouped(sink, groupNames(spec.groups), call.orderBy);
+      } else {
+        sink.text(spec.groups.map((group) => fieldRef(group)).join(", "));
+        if (isRecord(call.orderBy) && Object.keys(call.orderBy).length > 0) {
+          emitOrder(table, call.orderBy, sink, "t");
+        } else {
+          sink.text(" order by ");
+          sink.text(spec.groups.map((group) => `${fieldRef(group)} asc nulls last`).join(", "));
+        }
+      }
+    }
+    if (call.limit !== undefined) {
+      const limit = String(call.limit);
+      sink.text(" limit ");
+      sink.param(limit);
+      sink.mark(`l:${limit}`);
+    }
+    if (typeof call.all === "string")
+      sink.mark(`all:${call.all}`);
+  };
+}
+function groupMark(groups) {
+  const parts = [];
+  for (const group of groups) {
+    parts.push(group.kind === "field" ? group.column.field : `b:${group.column.field}:${group.as}:${group.unit}:${String(group.shift)}`);
+  }
+  return parts.join(",");
+}
+function fieldRef(group) {
+  if (group.kind !== "field")
+    return fail2("OKM1120", "bucket group");
+  return `t.${quote(group.column.sql)}`;
+}
+function put(sink, outputs, wrote, expr, out) {
+  if (wrote.at > 0)
+    sink.text(", ");
+  sink.text(expr);
+  outputs?.fields.push({ key: out.key, at: wrote.at, decode: out.decode });
+  wrote.at += 1;
+}
+function decode(compiled, rows) {
+  const items = [];
+  for (const row of rows) {
+    const item = {};
+    for (const field of compiled.outputs.fields) {
+      const value = row[field.at];
+      const tag = field.key.slice(0, 2);
+      const name = field.key.slice(2);
+      if (tag === "g:") {
+        item[name] = cell(value, field.decode);
+      } else if (tag === "c:") {
+        item.count = Number(value ?? 0);
+      } else {
+        const group = tag === "s:" ? "sum" : tag === "a:" ? "avg" : tag === "n:" ? "min" : "max";
+        const into = item[group] ??= {};
+        into[name] = cell(value, field.decode);
+      }
+    }
+    items.push(item);
+  }
+  return items;
+}
+export {
+  build
+};

package/dist/shared/{pjr6xrm5.js → n0jmpgj1.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./j60w0dvr.js";
+} from "./bah9nbg3.js";
 import {
   selectedColumns,
   parseOrder,
@@ -14,8 +14,8 @@ import {
   list,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./kgwp4jdd.js";
 import {
   OkmError2,
   throwNamed2
@@ -34,21 +34,24 @@ var OPTIONS = [
   "signal",
   "timeout"
 ];
-function build(session, table, options, mods, view) {
+function build3(session, table, options, mods, view, pin) {
   try {
-    return plan(session, table, options, mods, view);
+    return plan(session, table, options, mods, view, pin);
   } catch (error) {
     throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
   }
 }
-function plan(session, table, options, mods, view) {
+function plan(session, table, options, mods, view, pin) {
   const record = isRecord(options) ? options : {};
+  if (Object.hasOwn(record, "search")) {
+    fail2("OKM1120", "page() does not take search in this version. Use find({ search, limit }) for a ranked list.", "Ranked pages are later. find({ search, limit }) returns one ranked list.");
+  }
   rejectKeys(record, OPTIONS, "page");
   const indexed = indexes(session.schema).get(table);
   if (indexed === undefined)
-    fail("OKM1120", `Table ${table} is not in the schema.`);
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
   if (record.limit === undefined)
-    fail("OKM1101", "page() needs a limit.");
+    fail2("OKM1101", "page() needs a limit.");
   const size = readLimit(record.limit);
   if (size < 1) {
     throw new OkmError2("invalid", "page() limit must be at least 1.", { kind: "invalid" });
@@ -73,7 +76,8 @@ function plan(session, table, options, mods, view) {
       timeout: record.timeout,
       route: record.route
     }, undefined, session.scope, session.schema.model[table], session.schema, view),
-    ...after !== undefined ? { after } : {}
+    ...after !== undefined ? { after } : {},
+    ...pin !== undefined ? { pin } : {}
   };
   return readHandle(session, table, call, mods, async (compiled, rows) => {
     const items = await decodeRows(compiled, rows, table);
@@ -92,7 +96,7 @@ function plan(session, table, options, mods, view) {
 }
 function orderKeys(table, orderBy) {
   if (orderBy !== undefined && !isRecord(orderBy)) {
-    fail("OKM1120", "orderBy must be an object of fields.");
+    fail2("OKM1120", "orderBy must be an object of fields.");
   }
   const keys = [];
   for (const field of Object.keys(orderBy ?? {})) {
@@ -103,7 +107,7 @@ function orderKeys(table, orderBy) {
     keys.push({ column, ...parseOrder(field, orderBy?.[field]) });
   }
   if (table.model.primary.length === 0) {
-    fail("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
+    fail2("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
   }
   for (const field of table.model.primary) {
     const column = table.columns.get(field);
@@ -181,17 +185,16 @@ function readCursor(token, signature, count) {
     }
   }
   if (!Array.isArray(parsed) || typeof parsed[0] !== "string") {
-    fail("OKM1130", "after is not a cursor that page() returned.");
+    fail2("OKM1130", "after is not a cursor that page() returned.");
   }
   if (parsed[0] !== signature) {
-    fail("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
+    fail2("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
   }
   const values = parsed.slice(1);
   if (values.length !== count || !values.every((value) => value === null || typeof value === "string")) {
-    fail("OKM1130", "after is not a cursor that page() returned.");
+    fail2("OKM1130", "after is not a cursor that page() returned.");
   }
   return values;
 }
-export {
-  build
-};
+
+export { build3 };