@jxsuite/connector 0.6.1 → 0.6.3

package/src/sqlite.ts

@@ -7,15 +7,17 @@
  * Supabase.
  */
 
+import { isString } from "@jxsuite/schema/guards";
 import { createBunSqliteDialect } from "./dialects/bun-sqlite.ts";
 import { deployWithDialect, testWithDialect } from "./provider-utils.ts";
 import type { Dialect } from "kysely";
-import type { ConnectorProvider } from "./provider-utils.ts";
+import type { ConnectorProvider, HostEnv } from "./provider-utils.ts";
 import type { ConnectionDef } from "./types.ts";
 
 /** Resolve the SQLite file path for a connection. */
-export function sqliteFilePath(connection: ConnectionDef, env: Record<string, unknown>): string {
-  const root = typeof env["JX_PROJECT_ROOT"] === "string" ? env["JX_PROJECT_ROOT"] : ".";
+export function sqliteFilePath(connection: ConnectionDef, env: HostEnv): string {
+  const projectRoot = env["JX_PROJECT_ROOT"];
+  const root = isString(projectRoot) ? projectRoot : ".";
   const name = connection.$name ?? "default";
   const file = connection.file ?? `./.jx/data/${name}.sqlite`;
   if (file === ":memory:" || file.startsWith("/")) {
@@ -25,7 +27,7 @@ export function sqliteFilePath(connection: ConnectionDef, env: Record<string, un
 }
 
 /** Build the bun:sqlite dialect for a connection. */
-function sqliteDialect(connection: ConnectionDef, env: Record<string, unknown>): Dialect {
+function sqliteDialect(connection: ConnectionDef, env: HostEnv): Dialect {
   return createBunSqliteDialect({ url: sqliteFilePath(connection, env) });
 }
 
@@ -34,14 +36,14 @@ export const Sqlite = {
   deploySchema: async (
     tables: Parameters<ConnectorProvider["deploySchema"]>[0],
     connection: ConnectionDef,
-    options: { env: Record<string, unknown>; dryRun?: boolean },
+    options: { env: HostEnv; dryRun?: boolean },
   ) => {
     const dialect = sqliteDialect(connection, options.env);
     return deployWithDialect(dialect, "sqlite", tables, { dryRun: options.dryRun ?? false });
   },
   dialect: sqliteDialect,
   kind: "sqlite",
-  testConnection: async (connection: ConnectionDef, env: Record<string, unknown>) => {
+  testConnection: async (connection: ConnectionDef, env: HostEnv) => {
     try {
       return await testWithDialect(sqliteDialect(connection, env));
     } catch (error) {

package/src/supabase.ts

@@ -8,29 +8,27 @@
  * never touch a postgres connection never import them.
  */
 
+import { isNonNullObject, isString } from "@jxsuite/schema/guards";
 import { deployWithDialect, testWithDialect } from "./provider-utils.ts";
 import type { Dialect } from "kysely";
-import type { ConnectorProvider } from "./provider-utils.ts";
+import type { ConnectorProvider, HostEnv } from "./provider-utils.ts";
 import type { ConnectionDef } from "./types.ts";
 
 /**
  * Resolve the postgres URL for a connection: Hyperdrive binding first, then `urlEnv`.
  *
  * @param {ConnectionDef} connection
- * @param {Record<string, unknown>} env
+ * @param {HostEnv} env
  * @returns {string}
  */
-export function resolvePostgresUrl(
-  connection: ConnectionDef,
-  env: Record<string, unknown>,
-): string {
+export function resolvePostgresUrl(connection: ConnectionDef, env: HostEnv): string {
   const { binding, urlEnv, $name = "connection" } = connection;
-  const bound = binding ? (env[binding] as { connectionString?: string } | undefined) : undefined;
-  if (bound && typeof bound.connectionString === "string") {
+  const bound = binding ? env[binding] : undefined;
+  if (isNonNullObject(bound) && "connectionString" in bound && isString(bound.connectionString)) {
     return bound.connectionString;
   }
   const url = urlEnv ? env[urlEnv] : undefined;
-  if (typeof url === "string" && url !== "") {
+  if (isString(url) && url !== "") {
     return url;
   }
   throw new Error(
@@ -62,15 +60,15 @@ export const Supabase = {
   deploySchema: async (
     tables: Parameters<ConnectorProvider["deploySchema"]>[0],
     connection: ConnectionDef,
-    options: { env: Record<string, unknown>; dryRun?: boolean },
+    options: { env: HostEnv; dryRun?: boolean },
   ) => {
     const dialect = await postgresDialect(resolvePostgresUrl(connection, options.env));
     return deployWithDialect(dialect, "postgres", tables, { dryRun: options.dryRun ?? false });
   },
-  dialect: (connection: ConnectionDef, env: Record<string, unknown>) =>
+  dialect: (connection: ConnectionDef, env: HostEnv) =>
     postgresDialect(resolvePostgresUrl(connection, env)),
   kind: "postgres",
-  testConnection: async (connection: ConnectionDef, env: Record<string, unknown>) => {
+  testConnection: async (connection: ConnectionDef, env: HostEnv) => {
     try {
       const dialect = await postgresDialect(resolvePostgresUrl(connection, env));
       return await testWithDialect(dialect);

package/src/table-actions.ts

@@ -8,7 +8,9 @@
  * an equivalent real function.
  */
 
+import { isFunction, isString } from "@jxsuite/schema/guards";
 import { jsObjectSource, jsValueSource, resolveIdValue } from "./table-shared.ts";
+import type { JsonObject, JsonValue } from "@jxsuite/schema/types";
 import type { LowerContext } from "./table-state.ts";
 
 export type ActionMethod = "POST" | "PATCH" | "DELETE";
@@ -16,13 +18,23 @@ export type ActionMethod = "POST" | "PATCH" | "DELETE";
 /** The def shape all three action classes accept. */
 export interface ActionDef {
   table?: string;
-  id?: unknown;
+  id?: JsonValue;
   /** Literal payload columns merged over the submitting form's FormData. */
-  values?: Record<string, unknown>;
+  values?: JsonObject;
   _document?: { route?: { _pathParams?: Record<string, string> } };
-  [key: string]: unknown;
 }
 
+/**
+ * The live state scope an action handler runs against (interpreter path): `${...}` values are
+ * evaluated against it as `state`, and a successful write bumps its `_v` read-after-write counter.
+ */
+export interface ActionScope {
+  _v?: number;
+}
+
+/** A `values` entry compiled to a template function over the live state scope. */
+type ValueTemplate = (state: ActionScope) => string;
+
 /** Build the /_jx/data URL JS-source expression for a lowered action. */
 function urlSource(method: ActionMethod, def: ActionDef, context: LowerContext): string {
   const table = def.table ?? "";
@@ -39,13 +51,13 @@ function urlSource(method: ActionMethod, def: ActionDef, context: LowerContext):
  * @param {ActionMethod} method
  * @param {ActionDef} def
  * @param {LowerContext} [context]
- * @returns {Record<string, unknown>} A core Function def with an `event` parameter
+ * @returns {JsonObject} A core Function def with an `event` parameter
  */
 export function lowerActionDef(
   method: ActionMethod,
   def: ActionDef,
   context: LowerContext = {},
-): Record<string, unknown> {
+): JsonObject {
   const url = urlSource(method, def, context);
   const lines: string[] = [
     "if (event && typeof event.preventDefault === 'function') event.preventDefault();",
@@ -82,17 +94,14 @@ export function lowerActionDef(
 }
 
 /** Evaluate a `${...}`-bearing values object against a live scope (interpreter path). */
-function evaluateValues(
-  values: Record<string, unknown> | undefined,
-  scope: Record<string, unknown>,
-): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
+function evaluateValues(values: JsonObject | undefined, scope: ActionScope): JsonObject {
+  const out: JsonObject = {};
   for (const [key, value] of Object.entries(values ?? {})) {
-    if (typeof value === "string" && value.includes("${")) {
+    if (isString(value) && value.includes("${")) {
       try {
-        const fn = new Function("state", `return \`${value}\`;`) as (
-          state: Record<string, unknown>,
-        ) => unknown;
+        /* SAFETY: the body is a single `return` of a template literal, so the compiled function
+           takes the state scope as its one parameter and always returns a string. */
+        const fn = new Function("state", `return \`${value}\`;`) as ValueTemplate;
         out[key] = fn(scope);
       } catch {
         out[key] = value;
@@ -109,12 +118,12 @@ function evaluateValues(
  *
  * @param {ActionMethod} method
  * @param {ActionDef} config
- * @returns {(scope: Record<string, unknown>, event?: Event) => Promise<boolean>} Resolves true when
- *   the write succeeded (and `scope._v` was bumped)
+ * @returns {(scope: ActionScope, event?: Event) => Promise<boolean>} Resolves true when the write
+ *   succeeded (and `scope._v` was bumped)
  */
 export function makeActionHandler(method: ActionMethod, config: ActionDef) {
-  return async (scope: Record<string, unknown>, event?: Event): Promise<boolean> => {
-    if (event && typeof event.preventDefault === "function") {
+  return async (scope: ActionScope, event?: Event): Promise<boolean> => {
+    if (event && isFunction(event.preventDefault)) {
       event.preventDefault();
     }
     const table = config.table ?? "";
@@ -129,10 +138,15 @@ export function makeActionHandler(method: ActionMethod, config: ActionDef) {
     if (method === "DELETE") {
       init = { method };
     } else {
+      /* SAFETY: the handler is bound as an element's event listener (onsubmit/onclick), so the
+         event's target is the HTML element that dispatched it; `form` is read optionally because
+         only form-associated controls carry it. */
       const target = event?.target as
         | (HTMLElement & { form?: HTMLFormElement | null })
         | null
         | undefined;
+      /* SAFETY: Element.tagName reads "FORM" exactly for the HTML <form> element (HTML-namespace
+         tag names are reported uppercase), which is an HTMLFormElement. */
       form =
         target && target.tagName === "FORM" ? (target as HTMLFormElement) : (target?.form ?? null);
       const formData = form ? Object.fromEntries(new FormData(form)) : {};
@@ -146,10 +160,10 @@ export function makeActionHandler(method: ActionMethod, config: ActionDef) {
 
     const response = await fetch(url, init);
     if (response.ok) {
-      if (method === "POST" && form && typeof form.reset === "function") {
+      if (method === "POST" && form && isFunction(form.reset)) {
         form.reset();
       }
-      scope._v = ((scope._v as number) || 0) + 1;
+      scope._v = (scope._v || 0) + 1;
     }
     return response.ok;
   };

package/src/table-delete.ts

@@ -6,6 +6,7 @@
  */
 
 import { lowerActionDef, makeActionHandler } from "./table-actions.ts";
+import type { JsonObject } from "@jxsuite/schema/types";
 import type { ActionDef } from "./table-actions.ts";
 import type { LowerContext } from "./table-state.ts";
 
@@ -22,7 +23,7 @@ export class TableDelete {
   }
 
   /** Static `lower` capability: compile away into an inline Function def. */
-  static lower(def: ActionDef, context: LowerContext = {}): Record<string, unknown> {
+  static lower(def: ActionDef, context: LowerContext = {}): JsonObject {
     return lowerActionDef("DELETE", def, context);
   }
 }

package/src/table-insert.ts

@@ -7,6 +7,7 @@
  */
 
 import { lowerActionDef, makeActionHandler } from "./table-actions.ts";
+import type { JsonObject } from "@jxsuite/schema/types";
 import type { ActionDef } from "./table-actions.ts";
 import type { LowerContext } from "./table-state.ts";
 
@@ -23,7 +24,7 @@ export class TableInsert {
   }
 
   /** Static `lower` capability: compile away into an inline Function def. */
-  static lower(def: ActionDef, context: LowerContext = {}): Record<string, unknown> {
+  static lower(def: ActionDef, context: LowerContext = {}): JsonObject {
     return lowerActionDef("POST", def, context);
   }
 }

package/src/table-node.ts

@@ -8,6 +8,7 @@
  * empty results.
  */
 
+import { isNumber } from "@jxsuite/schema/guards";
 import { Kysely } from "kysely";
 import { fromStorage, planTable } from "./columns.ts";
 import { resolveDialect } from "./connectors.ts";
@@ -15,20 +16,23 @@ import { syncTables } from "./ddl.ts";
 import { applyFilter, applySort, normalizeFilter, normalizeSort } from "./query.ts";
 import { tablesForConnection } from "./provider-utils.ts";
 import type { SqlDialectKind } from "./columns.ts";
+import type { JsonValue } from "@jxsuite/schema/types";
 import type { ConnectionsConfig } from "./connectors.ts";
-import type { DynamicDatabase } from "./query.ts";
+import type { DynamicDatabase, DynamicRow } from "./query.ts";
 import type { TableQueryDef } from "./table-shared.ts";
 import type { TableDef } from "./types.ts";
 
+/** The project context hosts inject under `_project`: its config, root, and data section. */
+export interface TableProjectContext {
+  config?: ConnectionsConfig & { data?: Record<string, TableDef> };
+  root?: string;
+  data?: Record<string, TableDef>;
+}
+
 /** The `_project`-bearing config shape hosts inject into state classes. */
 export interface TableNodeConfig extends TableQueryDef {
-  id?: unknown;
-  _project?: {
-    config?: ConnectionsConfig & { data?: Record<string, TableDef> };
-    root?: string;
-    data?: Record<string, TableDef>;
-    [key: string]: unknown;
-  };
+  id?: JsonValue;
+  _project?: TableProjectContext;
 }
 
 interface OpenedTable {
@@ -48,10 +52,10 @@ async function openTable(config: TableNodeConfig): Promise<OpenedTable> {
   if (!tableDef) {
     throw new Error(`unknown table "${tableName}" (no data section entry)`);
   }
-  const env: Record<string, unknown> = {
-    ...process.env,
-    ...(project.root === undefined ? {} : { JX_PROJECT_ROOT: project.root }),
-  };
+  const env = { ...process.env };
+  if (project.root !== undefined) {
+    env["JX_PROJECT_ROOT"] = project.root;
+  }
   const { dialect, type } = await resolveDialect(tableDef.connection, projectConfig, env);
   const db = new Kysely<DynamicDatabase>({ dialect });
   const connection = projectConfig.connections?.[tableDef.connection];
@@ -66,19 +70,19 @@ async function openTable(config: TableNodeConfig): Promise<OpenedTable> {
  * Query a table with the def's filter/sort/limit/offset (the content grammar).
  *
  * @param {TableNodeConfig} config
- * @returns {Promise<Record<string, unknown>[]>}
+ * @returns {Promise<DynamicRow[]>}
  */
-export async function queryTable(config: TableNodeConfig): Promise<Record<string, unknown>[]> {
+export async function queryTable(config: TableNodeConfig): Promise<DynamicRow[]> {
   const { db, kind, tables, tableName } = await openTable(config);
   try {
     const plan = planTable(tableName, tables[tableName]!, tables, kind);
     let qb = db.selectFrom(tableName).selectAll();
     qb = applyFilter(qb, normalizeFilter(config.filter), plan.columns);
     qb = applySort(qb, normalizeSort(config.sort), plan.columns);
-    if (typeof config.limit === "number" && config.limit > 0) {
+    if (isNumber(config.limit) && config.limit > 0) {
       qb = qb.limit(config.limit);
     }
-    if (typeof config.offset === "number" && config.offset > 0) {
+    if (isNumber(config.offset) && config.offset > 0) {
       qb = qb.limit(config.limit ?? 100_000_000).offset(config.offset);
     }
     const rows = await qb.execute();
@@ -93,12 +97,9 @@ export async function queryTable(config: TableNodeConfig): Promise<Record<string
  *
  * @param {TableNodeConfig} config
  * @param {string} id
- * @returns {Promise<Record<string, unknown> | null>}
+ * @returns {Promise<DynamicRow | null>}
  */
-export async function getEntry(
-  config: TableNodeConfig,
-  id: string,
-): Promise<Record<string, unknown> | null> {
+export async function getEntry(config: TableNodeConfig, id: string): Promise<DynamicRow | null> {
   const { db, kind, tables, tableName } = await openTable(config);
   try {
     const plan = planTable(tableName, tables[tableName]!, tables, kind);

package/src/table-shared.ts

@@ -12,6 +12,9 @@
  * machinery.
  */
 
+import { isJsonObject, isNumber, isRef, isString } from "@jxsuite/schema/guards";
+import type { JsonObject, JsonValue } from "@jxsuite/schema/types";
+
 /** A `${...}` template span (Jx binding syntax preserved through lowering). */
 const TEMPLATE_SPAN = /(\$\{[^}]*\})/;
 
@@ -32,12 +35,13 @@ export function encodeQueryValue(value: string): string {
 /** The wire-facing query options a TableQuery/TableEntry def may carry. */
 export interface TableQueryDef {
   table?: string;
-  filter?: unknown;
-  sort?: unknown;
+  /** The content filter grammar: a rule array or an equality-object shorthand. */
+  filter?: JsonValue;
+  /** One `{ field, order }` sort rule or a list of them. */
+  sort?: JsonValue;
   limit?: number;
   offset?: number;
   include?: string | string[];
-  [key: string]: unknown;
 }
 
 /**
@@ -60,10 +64,10 @@ export function buildDataUrl(
   if (def.sort !== undefined && def.sort !== null) {
     parts.push(`sort=${encodeQueryValue(JSON.stringify(def.sort))}`);
   }
-  if (typeof def.limit === "number") {
+  if (isNumber(def.limit)) {
     parts.push(`limit=${def.limit}`);
   }
-  if (typeof def.offset === "number") {
+  if (isNumber(def.offset)) {
     parts.push(`offset=${def.offset}`);
   }
   const include = Array.isArray(def.include) ? def.include.join(",") : def.include;
@@ -82,23 +86,22 @@ export function buildDataUrl(
  * Resolve an id value: `#/$params/<name>` refs read route params, everything else passes through as
  * a string (template placeholders included).
  *
- * @param {unknown} id - The def's id value
+ * @param {JsonValue | undefined} id - The def's id value
  * @param {Record<string, string> | undefined} pathParams - Route params when known
  * @returns {string | undefined}
  */
 export function resolveIdValue(
-  id: unknown,
+  id: JsonValue | undefined,
   pathParams: Record<string, string> | undefined,
 ): string | undefined {
   if (id === null || id === undefined) {
     return undefined;
   }
-  if (typeof id === "object") {
-    const ref = (id as { $ref?: string }).$ref;
-    if (typeof ref === "string" && ref.startsWith("#/$params/")) {
-      const param = ref.slice("#/$params/".length);
-      return pathParams?.[param];
-    }
+  if (isRef(id) && id.$ref.startsWith("#/$params/")) {
+    const param = id.$ref.slice("#/$params/".length);
+    return pathParams?.[param];
+  }
+  if (Array.isArray(id) || isJsonObject(id)) {
     return undefined;
   }
   return String(id);
@@ -108,19 +111,20 @@ export function resolveIdValue(
  * Emit the JS source for a literal value inside a lowered Function body. Strings carrying `${...}`
  * become template literals (evaluated against state at runtime); everything else is inlined JSON.
  *
- * @param {unknown} value
+ * @param {JsonValue | undefined} value
  * @returns {string}
  */
-export function jsValueSource(value: unknown): string {
-  if (typeof value === "string" && value.includes("${")) {
+export function jsValueSource(value: JsonValue | undefined): string {
+  if (isString(value) && value.includes("${")) {
     const escaped = value.replaceAll("\\", String.raw`\\`).replaceAll("`", "\\`");
     return `\`${escaped}\``;
   }
-  return JSON.stringify(value) ?? "null";
+  // JSON.stringify(undefined) yields undefined rather than a string; an absent value inlines null.
+  return value === undefined ? "null" : JSON.stringify(value);
 }
 
 /** Emit the JS source of an object literal whose values go through {@link jsValueSource}. */
-export function jsObjectSource(values: Record<string, unknown> | undefined): string {
+export function jsObjectSource(values: JsonObject | undefined): string {
   if (!values || Object.keys(values).length === 0) {
     return "{}";
   }

package/src/table-state.ts

@@ -14,42 +14,55 @@
  * cache-busting param — see table-shared.ts.
  */
 
+import { isFunction } from "@jxsuite/schema/guards";
 import { buildDataUrl, resolveIdValue } from "./table-shared.ts";
+import type { JsonObject, JsonValue } from "@jxsuite/schema/types";
+import type { DynamicRow } from "./query.ts";
 import type { TableQueryDef } from "./table-shared.ts";
+import type { TableNodeConfig, getEntry, queryTable } from "./table-node.ts";
 
 /** Route/document context injected by hosts under `_document`. */
 interface DocumentContext {
   route?: { _pathParams?: Record<string, string> };
-  [key: string]: unknown;
 }
 
 /** The context object hosts pass to `lower(def, context)`. */
 export interface LowerContext {
   route?: { _pathParams?: Record<string, string>; sourcePath?: string };
-  projectConfig?: Record<string, unknown>;
+  projectConfig?: JsonObject;
   root?: string;
 }
 
-interface TableStateConfig extends TableQueryDef {
-  id?: unknown;
+interface TableStateConfig extends TableNodeConfig {
   _document?: DocumentContext;
-  _project?: Record<string, unknown>;
+}
+
+/**
+ * A TableQuery/TableEntry def as authored in a document, which is pure JSON: the query options, the
+ * `id` and `default` keys `lower` reads, and the class keys it carries past ($prototype, …).
+ */
+interface TableLowerDef extends TableQueryDef {
+  id?: JsonValue;
+  default?: JsonValue;
+  [key: string]: JsonValue | undefined;
 }
 
 /** True when running in a browser (canvas/client); node hosts take the direct-database path. */
 function inBrowser(): boolean {
-  return typeof document !== "undefined" && typeof fetch === "function";
+  return typeof document !== "undefined" && isFunction(globalThis.fetch);
 }
 
 /** The surface of the node-only sibling module (see table-node.ts). */
 interface TableNodeModule {
-  queryTable: (config: TableStateConfig) => Promise<unknown>;
-  getEntry: (config: TableStateConfig, id: string) => Promise<unknown>;
+  queryTable: typeof queryTable;
+  getEntry: typeof getEntry;
 }
 
 /** Import the node-only sibling through an opaque specifier (bundlers must not follow it). */
 async function nodeModule(): Promise<TableNodeModule> {
   const specifier = "./table-node.ts";
+  /* SAFETY: the opaque specifier is the literal "./table-node.ts" sibling, whose exports include
+     these two functions with exactly the types imported above. */
   return (await import(specifier)) as TableNodeModule;
 }
 
@@ -61,10 +74,12 @@ export class TableQuery {
   }
 
   /** Rows matching the def's filter/sort/limit — over HTTP in browsers, directly under node. */
-  async resolve(): Promise<unknown> {
+  async resolve(): Promise<DynamicRow[]> {
     if (inBrowser()) {
       const response = await fetch(buildDataUrl(this.config));
-      return response.ok ? await response.json() : [];
+      /* SAFETY: a 2xx from GET /_jx/data/:table is the data mount's list answer, Response.json()
+         of the row array (worker.ts listRows), so the parsed body is an array of row objects. */
+      return response.ok ? ((await response.json()) as DynamicRow[]) : [];
     }
     try {
       const { queryTable } = await nodeModule();
@@ -77,11 +92,11 @@ export class TableQuery {
   }
 
   /** Static `lower` capability: compile away into a core Request def (client fetch). */
-  static lower(def: Record<string, unknown>): Record<string, unknown> {
+  static lower(def: TableLowerDef): JsonObject {
     return {
       $prototype: "Request",
       timing: "client",
-      url: buildDataUrl(def as TableQueryDef, { versionParam: true }),
+      url: buildDataUrl(def, { versionParam: true }),
       ...(def.default === undefined ? { default: [] } : { default: def.default }),
     };
   }
@@ -95,7 +110,7 @@ export class TableEntry {
   }
 
   /** One row by id (`#/$params/` refs resolve against the route), or null. */
-  async resolve(): Promise<unknown> {
+  async resolve(): Promise<DynamicRow | null> {
     const { _document } = this.config;
     const id = resolveIdValue(this.config.id, _document?.route?._pathParams);
     if (id === undefined || id === "") {
@@ -103,7 +118,9 @@ export class TableEntry {
     }
     if (inBrowser()) {
       const response = await fetch(buildDataUrl(this.config, { id }));
-      return response.ok ? await response.json() : null;
+      /* SAFETY: a 2xx from GET /_jx/data/:table/:id is the data mount's single-row answer,
+         Response.json() of one row object (worker.ts getRow). */
+      return response.ok ? ((await response.json()) as DynamicRow) : null;
     }
     try {
       const { getEntry } = await nodeModule();
@@ -116,7 +133,7 @@ export class TableEntry {
   }
 
   /** Static `lower` capability: compile away into a core Request def for one row. */
-  static lower(def: Record<string, unknown>, context: LowerContext = {}): Record<string, unknown> {
+  static lower(def: TableLowerDef, context: LowerContext = {}): JsonObject {
     const id = resolveIdValue(def.id, context.route?._pathParams);
     if (id === undefined) {
       console.warn(
@@ -127,7 +144,7 @@ export class TableEntry {
     return {
       $prototype: "Request",
       timing: "client",
-      url: buildDataUrl(def as TableQueryDef, { id: id ?? "", versionParam: true }),
+      url: buildDataUrl(def, { id: id ?? "", versionParam: true }),
       ...(def.default === undefined ? { default: null } : { default: def.default }),
     };
   }

package/src/table-update.ts

@@ -7,6 +7,7 @@
  */
 
 import { lowerActionDef, makeActionHandler } from "./table-actions.ts";
+import type { JsonObject } from "@jxsuite/schema/types";
 import type { ActionDef } from "./table-actions.ts";
 import type { LowerContext } from "./table-state.ts";
 
@@ -23,7 +24,7 @@ export class TableUpdate {
   }
 
   /** Static `lower` capability: compile away into an inline Function def. */
-  static lower(def: ActionDef, context: LowerContext = {}): Record<string, unknown> {
+  static lower(def: ActionDef, context: LowerContext = {}): JsonObject {
     return lowerActionDef("PATCH", def, context);
   }
 }