okmodel 0.8.0 → 0.9.1

package/dist/shared/{35q0n9tz.js → jvxcp1qk.js}

@@ -6,7 +6,7 @@ import {
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./ae4j5f42.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/postgresjs.ts
 import net from "node:net";
@@ -36,41 +36,29 @@ class PoolSockets {
       this.park();
     });
   }
-  busyGate() {
+  gate(key) {
     return {
       enter: () => {
-        this.busy += 1;
+        this[key] += 1;
         this.wake();
       },
       leave: () => {
-        this.busy -= 1;
-        this.park();
-      }
-    };
-  }
-  listenerGate() {
-    return {
-      enter: () => {
-        this.listeners += 1;
-        this.wake();
-      },
-      leave: () => {
-        this.listeners -= 1;
+        this[key] -= 1;
         this.park();
       }
     };
   }
   wake() {
-    for (const socket of this.held)
-      if (socket.writable)
-        socket.ref();
+    for (const s of this.held)
+      if (s.writable)
+        s.ref();
   }
   park() {
     if (this.busy > 0 || this.listeners > 0)
       return;
-    for (const socket of this.held)
-      if (socket.writable)
-        socket.unref();
+    for (const s of this.held)
+      if (s.writable)
+        s.unref();
   }
 }
 function driverOptions(config, state) {
@@ -80,6 +68,7 @@ function driverOptions(config, state) {
     idle_timeout: state.plain ? 0 : 30,
     ...state.plain ? { max_lifetime: null } : {},
     connect_timeout: 5,
+    backoff: () => 0.05 + Math.random() * 0.2,
     types: WIRE_TYPES,
     ...state.plain ? { socket: (options) => state.sockets.connect(options) } : {},
     ...config.ssl !== undefined ? { ssl: config.ssl } : {},
@@ -92,9 +81,24 @@ function driverOptions(config, state) {
     }
   };
 }
+var lives = [];
+process.on("uncaughtException", (e) => {
+  if (e instanceof TypeError && /socket\.write|reading 'write'/.test(e.message)) {
+    for (const x of lives) {
+      if (!x.on)
+        continue;
+      const prev = x.sql;
+      x.m();
+      prev.end({ timeout: 0 }).catch(() => {});
+    }
+    return;
+  }
+  console.error(e);
+  process.exitCode = 1;
+});
 function open2(config) {
   const max = config.max ?? 10;
-  const acquireMs = config.timeouts?.acquire;
+  const acquireMs = config.timeouts?.acquire ?? 1e4;
   const counters = { reserved: 0, busy: 0, reservedBusy: 0, waiting: 0 };
   const poolInflight = new Set;
   const notices = noticeBuffer();
@@ -103,48 +107,56 @@ function open2(config) {
   const named = config.prepared === "named";
   const plain = config.ssl === undefined;
   const sockets = new PoolSockets;
-  const sql = postgres(config.url, driverOptions(config, {
-    max,
-    named,
-    plain,
+  const opts = { max, named, plain, notices, sockets };
+  const make = () => postgres(config.url, driverOptions(config, opts));
+  const root = new PgSession(make(), counters, "pool", poolInflight, isClosed, undefined, notices, named);
+  const held = {
+    on: true,
+    m: () => root.sql = make(),
+    get sql() {
+      return root.sql;
+    },
+    acquireMs,
+    counters,
+    isClosed,
     notices,
-    sockets
-  }));
-  const root = new PgSession(sql, counters, "pool", poolInflight, isClosed, undefined, notices, named);
-  const held = { sql, acquireMs, counters, isClosed, notices, named, poolInflight };
+    named,
+    poolInflight
+  };
+  lives.push(held);
   return {
     capabilities: POSTGRESJS_CAPABILITIES,
     execute(text, params, options) {
       return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
     },
     batch(statements, options) {
-      return sockets.occupy(() => import("./z581d7ny.js").then((mod) => mod.runBatch(held, statements, options)));
+      return sockets.occupy(() => import("./hgt69zjf.js").then((mod) => mod.runBatch(held, statements, options)));
     },
     reserve() {
-      const gate = sockets.busyGate();
+      const gate = sockets.gate("busy");
       gate.enter();
-      return import("./z581d7ny.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+      return import("./hgt69zjf.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
         gate.leave();
         throw error;
       });
     },
-    describe: (text, params) => sockets.occupy(() => import("./z581d7ny.js").then((mod) => mod.describe(sql, text, params))),
+    describe: (text, params) => sockets.occupy(() => import("./hgt69zjf.js").then((mod) => mod.describe(root.sql, text, params))),
     stream(text, params) {
-      const gate = sockets.busyGate();
+      const gate = sockets.gate("busy");
       return async function* () {
         gate.enter();
         try {
-          yield* loadStream(sql, text, params);
+          yield* (await import("./hgt69zjf.js")).stream(root.sql, text, params);
         } finally {
           gate.leave();
         }
       }();
     },
     listen(channel, onNotify) {
-      const gate = sockets.listenerGate();
+      const gate = sockets.gate("listeners");
       gate.enter();
-      return import("./z581d7ny.js").then((mod) => mod.holdListener(gate, async () => {
-        const listening = await sql.listen(channel, onNotify);
+      return import("./hgt69zjf.js").then((mod) => mod.holdListener(gate, async () => {
+        const listening = await root.sql.listen(channel, onNotify);
         return async () => {
           await listening.unlisten();
         };
@@ -160,7 +172,8 @@ function open2(config) {
     stats: () => statsOf(counters, max),
     async close() {
       closed = true;
-      await sql.end({ timeout: 5 });
+      held.on = false;
+      await root.sql.end({ timeout: 5 });
     }
   };
 }
@@ -213,7 +226,7 @@ class PgSession {
       onAbort();
     else
       watch.signal.addEventListener("abort", onAbort, { once: true });
-    return import("./z581d7ny.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+    return import("./hgt69zjf.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
       start,
       text,
       notices: this.notices,
@@ -252,67 +265,38 @@ class PgSession {
     this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
   }
   enter() {
-    if (this.scope === "pool")
-      this.counters.busy += 1;
-    else
-      this.counters.reservedBusy += 1;
+    this.counters[this.scope === "pool" ? "busy" : "reservedBusy"] += 1;
   }
   leave() {
-    if (this.scope === "pool")
-      this.counters.busy = Math.max(0, this.counters.busy - 1);
-    else
-      this.counters.reservedBusy = Math.max(0, this.counters.reservedBusy - 1);
+    const k = this.scope === "pool" ? "busy" : "reservedBusy";
+    this.counters[k] = Math.max(0, this.counters[k] - 1);
   }
 }
-async function* loadStream(sql, text, params) {
-  const { stream } = await import("./z581d7ny.js");
-  yield* stream(sql, text, params);
-}
 function send(sql, text, params, named) {
-  if (!named && (params === undefined || params.length === 0))
-    return sql.unsafe(text).raw();
-  return sql.unsafe(text, asParams(params), { prepare: named }).raw();
-}
-function asParams(params) {
-  if (params === undefined)
-    return [];
-  return params;
-}
-function statsOf(counters, size) {
-  return {
-    size,
-    idle: Math.max(0, size - counters.reserved - counters.busy),
-    inflight: counters.busy + counters.reservedBusy,
-    waiting: counters.waiting
-  };
+  return !named && (params === undefined || params.length === 0) ? sql.unsafe(text).raw() : sql.unsafe(text, asParams(params), { prepare: named }).raw();
 }
+var asParams = (params) => params ?? [];
+var statsOf = (c, size) => ({
+  size,
+  idle: Math.max(0, size - c.reserved - c.busy),
+  inflight: c.busy + c.reservedBusy,
+  waiting: c.waiting
+});
 function noticeBuffer() {
   let notices;
   return {
     push(notice) {
       const severity = typeof notice.severity === "string" ? notice.severity : "";
       const message = typeof notice.message === "string" ? notice.message : "";
-      const code = typeof notice.code === "string" && notice.code.length > 0 ? notice.code : undefined;
-      const entry = code === undefined ? { severity, message } : { severity, message, code };
-      (notices ??= []).push(entry);
-    },
-    start() {
-      return notices?.length ?? 0;
+      const code = typeof notice.code === "string" && notice.code ? notice.code : undefined;
+      (notices ??= []).push(code ? { severity, message, code } : { severity, message });
     },
-    since(start) {
-      if (notices === undefined || notices.length === start)
-        return EMPTY_NOTICES;
-      return notices.slice(start);
-    }
+    start: () => notices?.length ?? 0,
+    since: (start) => notices === undefined || notices.length === start ? EMPTY_NOTICES : notices.slice(start)
   };
 }
 function wire(to, from) {
-  return {
-    to,
-    from: [...from],
-    serialize: (value) => value,
-    parse: (value) => value
-  };
+  return { to, from, serialize: String, parse: String };
 }
 var WIRE_TYPES = {
   number: wire(0, [21, 23, 26, 700, 701]),

package/dist/shared/k73e8n9d.js

@@ -0,0 +1,136 @@
+import {
+  POSTGRES_FLOOR,
+  isPostgresMajor,
+  parsePostgresFloor,
+  serverNeedsPostgres
+} from "./ga9j92qj.js";
+import {
+  withHttp,
+  attachHttp,
+  mapOptions
+} from "./xbvz446k.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/artifact-file.ts
+function artifactDir(catalogDir) {
+  if (catalogDir !== undefined)
+    return catalogDir.replace(/[/\\]+$/, "");
+  const cwd = globalThis.process?.cwd?.() ?? ".";
+  return `${cwd}/.okm`;
+}
+async function readText(path) {
+  const bun = globalThis.Bun;
+  if (bun !== undefined) {
+    const file = bun.file(path);
+    if (!await file.exists())
+      return;
+    return file.text();
+  }
+  const loader = globalThis.process?.getBuiltinModule;
+  if (loader === undefined)
+    return;
+  try {
+    return await loader("node:fs/promises").readFile(path, "utf8");
+  } catch {
+    return;
+  }
+}
+
+// src/runtime/server-check.ts
+var versionQuery = "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)";
+var historyQuery = "select migration_id, class, catalog_hash from okm_history order by migration_id, step_index";
+async function versionSql(namespace) {
+  if (namespace === "public")
+    return versionQuery;
+  const relation = await qualified("okm_meta", namespace);
+  const literal = relation.replaceAll("'", "''");
+  return `select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from ${literal} where id = ''head''', true, false, '')))[1]::text where to_regclass('${literal}') is not null)`;
+}
+async function historySql2(namespace) {
+  if (namespace === "public")
+    return historyQuery;
+  return `select migration_id, class, catalog_hash from ${await qualified("okm_history", namespace)} order by migration_id, step_index`;
+}
+async function recordedNamespace(catalogDir) {
+  const text = await readText(`${artifactDir(catalogDir)}/namespace`);
+  if (text === undefined)
+    return "public";
+  const line = text.trim();
+  if (line === "" || line === "public")
+    return "public";
+  if (line.includes("\x00") || line.includes(`
+`) || line.includes("\r")) {
+    throw new OkmError2("OKM1122", "The catalog namespace file is not one identifier.", {
+      fix: { summary: "Run okm build so .okm/namespace is the schema from defineConfig." }
+    });
+  }
+  return line;
+}
+async function acceptServer2(pool, schema, http, requireMeta, options, source) {
+  const namespace = await recordedNamespace(source.catalogDir);
+  let rows;
+  try {
+    const result = await pool.execute(await versionSql(namespace), undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    const { mapPostgresError } = await import("./vy47ryqa.js");
+    throw mapPostgresError(error, mapOptions(http, false, schema));
+  }
+  for (const name in schema.model) {
+    if (schema.model[name]?.presets !== undefined) {
+      (await import("./m7n9h2a5.js")).checkSchema(schema);
+      break;
+    }
+  }
+  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("./xbd9xs6p.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options, namespace);
+    } catch (error) {
+      if (error instanceof OkmError2)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
+  const raw = schema.requires?.postgres;
+  if (raw === undefined) {
+    if (major < POSTGRES_FLOOR) {
+      throw new OkmError2("OKM1803", serverNeedsPostgres(major, POSTGRES_FLOOR), withHttp(http, {
+        fix: {
+          summary: `Upgrade to PostgreSQL ${String(POSTGRES_FLOOR)} or higher.`
+        }
+      }));
+    }
+    return;
+  }
+  const need = parsePostgresFloor(raw);
+  if (!isPostgresMajor(need) || major < need) {
+    throw new OkmError2("OKM1802", serverNeedsPostgres(major, isPostgresMajor(need) ? need : POSTGRES_FLOOR), withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower minPostgres to a major the server meets." }
+    }));
+  }
+}
+async function qualified(table, namespace) {
+  const { quoteIdent } = await import("./61bmrmhr.js");
+  return `${quoteIdent(namespace)}.${table}`;
+}
+
+export { artifactDir, readText, historySql2, acceptServer2 };

package/dist/shared/{195pzzzz.js → kzgrcy8s.js}

@@ -1,7 +1,8 @@
 import {
   open2
-} from "./35q0n9tz.js";
+} from "./jvxcp1qk.js";
 import"./12z7aznj.js";
+import"./fk9vef30.js";
 import"./n442h54c.js";
 import {
   CURRENT,
@@ -14,21 +15,22 @@ import {
 import {
   expandProvisioned,
   provisionHistoryIsKnown
-} from "./mnvjvqyp.js";
-import"./kj9d8maq.js";
-import"./p3xbdcvt.js";
+} from "./8p2bgye0.js";
+import"./6xqvesa5.js";
+import"./mz48rs74.js";
 import {
   projectPath,
+  catalogNamespace,
   loadMigrations,
   loadConfig
-} from "./f4jy1j7x.js";
+} from "./wp7y8q3y.js";
 import {
+  driverUrl,
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   listTargets
-} from "./dpc2r7rb.js";
-import"./sjk86yrx.js";
+} from "./bdekbvmt.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -82,7 +84,7 @@ function describeStatus(migrations, history, recorded) {
 async function readTargetStatus(input) {
   assertTargetPolicy({ name: input.target, protected: input.protected }, "status");
   const pool = open2({
-    url: input.url,
+    url: driverUrl(input.url),
     max: 1,
     ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {}
   });
@@ -109,6 +111,7 @@ async function readTargetStatus(input) {
 }
 async function statusProject(cwd, flags) {
   const config = await loadConfig(cwd);
+  const namespace = catalogNamespace(config);
   const targets = chosen(listTargets(config), flags.target);
   const migrations = loadMigrations(projectPath(cwd, config.migrations ?? "migrations"));
   const rows = [];
@@ -117,6 +120,7 @@ async function statusProject(cwd, flags) {
       url: target.url,
       target: target.name,
       protected: target.protected,
+      ...namespace === "public" ? {} : { searchPath: namespace },
       migrations
     }));
   }

package/dist/shared/kzgrnckd.js

@@ -0,0 +1,29 @@
+import {
+  isExactVersion,
+  compareExtensionVersions
+} from "./r3j8s5y0.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/ext/feature.ts
+function assertExtFeature(declared, feature, need) {
+  if (declared === undefined)
+    return;
+  if (pinAllows(declared, need.extension))
+    return;
+  throw new OkmError2("OKM1812", `${feature} needs ${need.name} ${need.extension} or higher and PostgreSQL ${String(need.postgres)}. minPostgres: ${String(need.postgres)}. The declaration allows ${declared}.`, {
+    fix: {
+      summary: `Raise the ${need.name} pin to ${need.extension} or higher, and set minPostgres to ${String(need.postgres)}.`
+    }
+  });
+}
+function pinAllows(declared, minimum) {
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(declared);
+  const pinned = floor?.[1] ?? declared;
+  if (!isExactVersion(pinned))
+    return false;
+  return compareExtensionVersions(pinned, minimum) >= 0;
+}
+
+export { assertExtFeature };

package/dist/shared/{p3xbdcvt.js → mz48rs74.js}

@@ -10,11 +10,11 @@ import {
   materializedViewIndex
 } from "./12z7aznj.js";
 import {
-  columnPrivilege
-} from "./dpc2r7rb.js";
+  quoteIdent2
+} from "./fk9vef30.js";
 import {
-  quoteIdent
-} from "./sjk86yrx.js";
+  columnPrivilege
+} from "./bdekbvmt.js";
 import {
   policyObject
 } from "./bdk4sty6.js";
@@ -265,7 +265,10 @@ async function introspectSchema(runner, concrete, logical = "public", options) {
       ...expression.length > 0 ? { expression } : {},
       ...refTable.length > 0 ? {
         references: {
-          parent: { namespace, name: refTable },
+          parent: {
+            namespace: referencedNamespace(text(row, "ref_schema"), concrete, namespace),
+            name: refTable
+          },
           columns: refColumns,
           ...onDelete !== undefined ? { onDelete } : {},
           ...onUpdate !== undefined ? { onUpdate } : {}
@@ -370,7 +373,7 @@ async function introspectSchema(runner, concrete, logical = "public", options) {
       events: triggerEvents(bits),
       level: (bits & 1) === 1 ? "row" : "statement",
       calls: {
-        namespace: staticNamespace2(text(row, "function_schema")),
+        namespace: referencedNamespace(text(row, "function_schema"), concrete, namespace),
         name: text(row, "function"),
         argTypes
       },
@@ -446,8 +449,38 @@ async function introspectSchema(runner, concrete, logical = "public", options) {
   if (options?.managedRoles !== undefined) {
     objects.push(...await readPrivileges(runner, concrete, logical, namespace, provenance, objects, options.managedRoles, options.reportingRole));
   }
+  await includeOutsideReferences(runner, logical, provenance, objects);
   return catalog(objects);
 }
+async function includeOutsideReferences(runner, logical, provenance, objects) {
+  const wanted = new Map;
+  for (const object of objects) {
+    if (object.kind !== "constraint" || object.definition.references === undefined)
+      continue;
+    const parent = object.definition.references.parent;
+    if (parent.namespace.form !== "static" || parent.namespace.name === logical)
+      continue;
+    wanted.set(`${parent.namespace.name}.${parent.name}`, {
+      schema: parent.namespace.name,
+      name: parent.name
+    });
+  }
+  for (const target of wanted.values()) {
+    const namespace = staticNamespace2(target.schema);
+    const parent = { namespace, name: target.name };
+    objects.push(table3({ namespace, name: target.name, provenance }));
+    const rows = await runner.query(OUTSIDE_COLUMNS, [target.schema, target.name]);
+    for (const row of rows) {
+      objects.push(column2({
+        parent,
+        name: text(row, "name"),
+        dataType: text(row, "type"),
+        nullable: !flag(row, "not_null"),
+        provenance
+      }));
+    }
+  }
+}
 var EMITTED = new Set(["SELECT", "INSERT", "UPDATE", "DELETE", "EXECUTE", "USAGE"]);
 var ROLES = `select rolname, rolcanlogin, rolinherit from pg_roles where rolname !~ '^pg_'`;
 var RELATION_GRANTS = `select c.relname as name,
@@ -704,10 +737,21 @@ function indexExpression(row, columns) {
   const opclasses = list(text(row, "opc"));
   const body = columns.map((name, index) => {
     const opclass = opclasses[index];
-    return opclass === undefined ? quoteIdent(name) : `${quoteIdent(name)} ${opclass}`;
+    return opclass === undefined ? quoteIdent2(name) : `${quoteIdent2(name)} ${opclass}`;
   }).join(", ");
   return `using ${method} (${body.length > 0 ? body : stored})`;
 }
+async function reprintDomainCheck(runner, base, expression) {
+  await runner.query("drop domain if exists okm_expr_domain");
+  await runner.query(`create domain okm_expr_domain as ${base} check (${expression})`);
+  const rows = await runner.query(`select pg_get_constraintdef(c.oid) as definition
+     from pg_constraint c
+     join pg_type t on t.oid = c.contypid
+     join pg_namespace n on n.oid = t.typnamespace
+     where t.typname = 'okm_expr_domain' and n.nspname = current_schema()`);
+  await runner.query("drop domain okm_expr_domain");
+  return checkExpression(text(rows[0] ?? {}, "definition"));
+}
 var CHILD = "not exists (select 1 from pg_inherits i where i.inhrelid = c.oid)";
 var TABLES = `
   select c.relname as name, pt.partstrat as partstrat,
@@ -761,6 +805,20 @@ var COLUMNS = `
     and ${CHILD}
     and ${member("c.oid", "pg_class")}
 `;
+function referencedNamespace(refSchema, concrete, logical) {
+  if (refSchema.length > 0 && refSchema !== concrete)
+    return staticNamespace2(refSchema);
+  return logical;
+}
+var OUTSIDE_COLUMNS = `
+  select a.attname as name, format_type(a.atttypid, a.atttypmod) as type, a.attnotnull as not_null
+  from pg_attribute a
+  join pg_class c on c.oid = a.attrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname = $1 and c.relname = $2
+    and a.attnum > 0 and not a.attisdropped
+  order by a.attnum
+`;
 var CONSTRAINTS = `
   select rel.relname as parent, con.conname as name, con.contype as contype,
     con.condeferrable as deferrable, con.condeferred as deferred,
@@ -771,6 +829,7 @@ var CONSTRAINTS = `
       join pg_attribute a on a.attrelid = con.conrelid and a.attnum = cols.attnum
     ) as columns,
     ref.relname as ref_table,
+    refn.nspname as ref_schema,
     (
       select coalesce(string_agg(a.attname, ',' order by cols.ord), '')
       from unnest(con.confkey) with ordinality as cols(attnum, ord)
@@ -780,6 +839,7 @@ var CONSTRAINTS = `
   join pg_class rel on rel.oid = con.conrelid
   join pg_namespace n on n.oid = rel.relnamespace
   left join pg_class ref on ref.oid = con.confrelid
+  left join pg_namespace refn on refn.oid = ref.relnamespace
   where n.nspname = $1
     and con.contype in ('p', 'u', 'f', 'c')
     and not exists (select 1 from pg_inherits i where i.inhrelid = rel.oid)
@@ -1033,4 +1093,4 @@ function flag(row, key) {
   return value === true || value === "true" || value === "t";
 }
 
-export { cellText, VIEW_DEPENDENCIES, viewDependencyEdges, PUBLIC, introspectSchema, FUNCTION_ARG_TYPES, atomicBody };
+export { cellText, VIEW_DEPENDENCIES, viewDependencyEdges, PUBLIC, introspectSchema, FUNCTION_ARG_TYPES, atomicBody, reprintDomainCheck };