@datafn/client 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1216 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EventBus: () => EventBus,
+  IndexedDbStorageAdapter: () => IndexedDbStorageAdapter,
+  MemoryStorageAdapter: () => MemoryStorageAdapter,
+  createClientError: () => createClientError,
+  createDatafnClient: () => createDatafnClient,
+  matchesFilter: () => matchesFilter,
+  unwrapRemoteSuccess: () => unwrapRemoteSuccess
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_core2 = require("@datafn/core");
+
+// src/events/filter.ts
+function matchesFilter(event, filter) {
+  if (!filter) return true;
+  if (filter.type !== void 0) {
+    if (Array.isArray(filter.type)) {
+      if (!filter.type.includes(event.type)) return false;
+    } else {
+      if (event.type !== filter.type) return false;
+    }
+  }
+  if (filter.resource !== void 0 && event.resource) {
+    if (Array.isArray(filter.resource)) {
+      if (!filter.resource.includes(event.resource)) return false;
+    } else {
+      if (event.resource !== filter.resource) return false;
+    }
+  }
+  if (filter.ids !== void 0 && event.ids) {
+    const filterIds = Array.isArray(filter.ids) ? filter.ids : [filter.ids];
+    const eventIds = Array.isArray(event.ids) ? event.ids : [event.ids];
+    const hasMatch = eventIds.some((id) => filterIds.includes(id));
+    if (!hasMatch) return false;
+  }
+  if (filter.mutationId !== void 0 && event.mutationId) {
+    if (Array.isArray(filter.mutationId)) {
+      if (!filter.mutationId.includes(event.mutationId)) return false;
+    } else {
+      if (event.mutationId !== filter.mutationId) return false;
+    }
+  }
+  if (filter.action !== void 0 && event.action) {
+    if (Array.isArray(filter.action)) {
+      if (!filter.action.includes(event.action)) return false;
+    } else {
+      if (event.action !== filter.action) return false;
+    }
+  }
+  if (filter.fields !== void 0 && event.fields) {
+    const filterFields = Array.isArray(filter.fields) ? filter.fields : [filter.fields];
+    const eventFields = Array.isArray(event.fields) ? event.fields : [event.fields];
+    const hasIntersection = filterFields.some((f) => eventFields.includes(f));
+    if (!hasIntersection) return false;
+  }
+  if (filter.contextKeys !== void 0 && filter.contextKeys.length > 0) {
+    if (!event.context || typeof event.context !== "object") {
+      return false;
+    }
+    const ctx = event.context;
+    const allExist = filter.contextKeys.every((key) => key in ctx);
+    if (!allExist) return false;
+  }
+  return true;
+}
+
+// src/events/bus.ts
+var EventBus = class {
+  constructor() {
+    this.subscriptions = [];
+    this.nextId = 1;
+  }
+  /**
+   * Subscribe to events with optional filtering
+   */
+  subscribe(handler, filter) {
+    const subscription = {
+      id: this.nextId++,
+      handler,
+      filter
+    };
+    this.subscriptions.push(subscription);
+    return () => {
+      this.subscriptions = this.subscriptions.filter(
+        (s) => s.id !== subscription.id
+      );
+    };
+  }
+  /**
+   * Emit an event to all matching subscribers
+   */
+  emit(event) {
+    for (const subscription of this.subscriptions) {
+      if (matchesFilter(event, subscription.filter)) {
+        subscription.handler(event);
+      }
+    }
+  }
+};
+
+// src/errors.ts
+function createClientError(code, message, details) {
+  const error = {
+    code,
+    message,
+    details
+  };
+  throw error;
+}
+function isTransportError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const err = error;
+  if (err.code === "TRANSPORT_ERROR") return true;
+  if (err.name === "TypeError" && err.message.includes("fetch")) return true;
+  if (err.name === "AbortError") return true;
+  return false;
+}
+
+// src/tables/table.ts
+function createTable(name, version, client, signalRegistry) {
+  return {
+    name,
+    version,
+    /**
+     * Execute a query with resource/version merged (CLIENT-QUERY-001)
+     */
+    async query(q) {
+      const fragment = typeof q === "object" && q !== null ? q : {};
+      const { resource: _r, version: _v, ...rest } = fragment;
+      const fullQuery = {
+        resource: name,
+        version,
+        ...rest
+      };
+      return client.query(fullQuery);
+    },
+    /**
+     * Execute a mutation with resource/version merged (CLIENT-MUT-001)
+     */
+    async mutate(m) {
+      const fragment = typeof m === "object" && m !== null ? m : {};
+      const { resource: _r, version: _v, ...rest } = fragment;
+      const fullMutation = {
+        resource: name,
+        version,
+        ...rest
+      };
+      return client.mutate(fullMutation);
+    },
+    /**
+     * Execute a transaction (CLIENT-TX-001)
+     */
+    async transact(payload) {
+      return client.transact(payload);
+    },
+    /**
+     * Create reactive query signal (CLIENT-SIGNAL-001)
+     */
+    signal(q) {
+      const fragment = typeof q === "object" && q !== null ? q : {};
+      const { resource: _r, version: _v, ...rest } = fragment;
+      const fullQuery = {
+        resource: name,
+        version,
+        ...rest
+      };
+      return signalRegistry.getSignal(fullQuery);
+    },
+    /**
+     * Subscribe to events for this table's resource (CLIENT-SUB-001)
+     */
+    subscribe(handler, filter) {
+      const tableFilter = {
+        ...filter,
+        resource: name
+        // Always use table's resource, ignore user-provided
+      };
+      return client.subscribe(handler, tableFilter);
+    }
+  };
+}
+
+// src/tables/registry.ts
+var TableRegistry = class {
+  constructor(schema, client, signalRegistry) {
+    this.schema = schema;
+    this.tables = /* @__PURE__ */ new Map();
+    this.client = client;
+    this.signalRegistry = signalRegistry;
+  }
+  /**
+   * Get a table handle by name.
+   * Caches table instances for object identity.
+   * Throws DFQL_UNKNOWN_RESOURCE for unknown tables.
+   */
+  getTable(name) {
+    const cached = this.tables.get(name);
+    if (cached) {
+      return cached;
+    }
+    const resource = this.schema.resources.find((r) => r.name === name);
+    if (!resource) {
+      createClientError("DFQL_UNKNOWN_RESOURCE", `Unknown resource: ${name}`, {
+        path: "resource",
+        resource: name
+      });
+    }
+    const table = createTable(
+      resource.name,
+      resource.version,
+      this.client,
+      this.signalRegistry
+    );
+    this.tables.set(name, table);
+    return table;
+  }
+  /**
+   * Get all declared table names from schema
+   */
+  getTableNames() {
+    return this.schema.resources.map((r) => r.name);
+  }
+};
+
+// src/remote/unwrap.ts
+function unwrapRemoteSuccess(response) {
+  if (typeof response !== "object" || response === null) {
+    createClientError(
+      "TRANSPORT_ERROR",
+      "Transport error: unexpected response shape",
+      { path: "$" }
+    );
+  }
+  const resp = response;
+  if ("ok" in resp) {
+    if (resp.ok === true && "result" in resp) {
+      return resp.result;
+    } else if (resp.ok === false && "error" in resp) {
+      const error = resp.error;
+      createClientError(
+        error.code || "INTERNAL",
+        error.message || "Unknown error",
+        error.details || { path: "$" }
+      );
+    }
+  }
+  if ("data" in resp && "nextCursor" in resp) {
+    return response;
+  }
+  if ("groups" in resp && "nextCursor" in resp) {
+    return response;
+  }
+  createClientError(
+    "TRANSPORT_ERROR",
+    "Transport error: unexpected response shape",
+    { path: "$" }
+  );
+}
+
+// src/offline/query.ts
+async function executeLocalQuery(storage, query) {
+  const resource = query.resource;
+  const select = query.select || [];
+  const filters = query.filters || {};
+  const sort = query.sort || [];
+  const limit = typeof query.limit === "number" ? query.limit : void 0;
+  const offset = typeof query.offset === "number" ? query.offset : 0;
+  let records = await storage.listRecords(resource);
+  if (Object.keys(filters).length > 0) {
+    records = records.filter((record) => matchesFilters(record, filters));
+  }
+  if (sort.length > 0) {
+    records.sort(createComparator(sort));
+  }
+  if (offset > 0) {
+    records = records.slice(offset);
+  }
+  if (limit !== void 0) {
+    records = records.slice(0, limit);
+  }
+  const data = records.map((record) => projectFields(record, select));
+  return {
+    data,
+    nextCursor: null
+    // Local cursor logic omitted for MVP (id-based or offset based)
+  };
+}
+function matchesFilters(record, filters) {
+  for (const [key, filterValue] of Object.entries(filters)) {
+    const recordValue = getDotPath(record, key);
+    if (typeof filterValue === "object" && filterValue !== null) {
+      if (!evaluateOperators(recordValue, filterValue)) {
+        return false;
+      }
+    } else {
+      if (recordValue !== filterValue) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function evaluateOperators(value, operators) {
+  for (const [op, target] of Object.entries(operators)) {
+    switch (op) {
+      case "$eq":
+      case "eq":
+        if (value !== target) return false;
+        break;
+      case "$neq":
+      case "neq":
+        if (value === target) return false;
+        break;
+      case "$in":
+      case "in":
+        if (Array.isArray(target) && !target.includes(value)) return false;
+        break;
+      case "$gt":
+      case "gt":
+        if (!(value > target)) return false;
+        break;
+      case "$lt":
+      case "lt":
+        if (!(value < target)) return false;
+        break;
+      case "$gte":
+      case "gte":
+        if (!(value >= target)) return false;
+        break;
+      case "$lte":
+      case "lte":
+        if (!(value <= target)) return false;
+        break;
+      case "$contains":
+      case "contains":
+        if (typeof value === "string" && typeof target === "string") {
+          if (!value.includes(target)) return false;
+        } else if (Array.isArray(value)) {
+          if (!value.includes(target)) return false;
+        } else {
+          return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+function createComparator(sortRules) {
+  return (a, b) => {
+    for (const rule of sortRules) {
+      const valA = getDotPath(a, rule.field);
+      const valB = getDotPath(b, rule.field);
+      if (valA === valB) continue;
+      const comparison = valA < valB ? -1 : 1;
+      return rule.dir === "asc" ? comparison : -comparison;
+    }
+    const idA = a.id;
+    const idB = b.id;
+    return idA < idB ? -1 : idA > idB ? 1 : 0;
+  };
+}
+function getDotPath(obj, path) {
+  return path.split(".").reduce((curr, part) => curr?.[part], obj);
+}
+function projectFields(record, select) {
+  if (!select || select.length === 0) {
+    return { ...record };
+  }
+  const projected = { id: record.id };
+  for (const field of select) {
+    if (field in record) {
+      projected[field] = record[field];
+    }
+  }
+  return projected;
+}
+
+// src/plugins/run-hooks.ts
+function getClientPlugins(plugins) {
+  return plugins.filter((p) => p.runsOn && p.runsOn.includes("client"));
+}
+async function runBeforeQuery(plugins, schema, query) {
+  let transformed = query;
+  const ctx = { env: "client", schema };
+  for (const plugin of getClientPlugins(plugins)) {
+    if (plugin.beforeQuery) {
+      try {
+        const result = await plugin.beforeQuery(ctx, transformed);
+        if (result !== void 0) {
+          transformed = result;
+        }
+      } catch (error) {
+        throw {
+          code: error.code || "INTERNAL",
+          message: error.message || "Plugin error",
+          details: {
+            path: `plugins.${plugin.name}.beforeQuery`,
+            ...error.details || {}
+          }
+        };
+      }
+    }
+  }
+  return transformed;
+}
+async function runAfterQuery(plugins, schema, query, result) {
+  let transformed = result;
+  const ctx = { env: "client", schema };
+  for (const plugin of getClientPlugins(plugins)) {
+    if (plugin.afterQuery) {
+      try {
+        const pluginResult = await plugin.afterQuery(ctx, query, transformed);
+        if (pluginResult !== void 0) {
+          transformed = pluginResult;
+        }
+      } catch (error) {
+        console.error(`Plugin ${plugin.name}.afterQuery failed:`, error);
+      }
+    }
+  }
+  return transformed;
+}
+async function runBeforeMutation(plugins, schema, mutation) {
+  let transformed = mutation;
+  const ctx = { env: "client", schema };
+  for (const plugin of getClientPlugins(plugins)) {
+    if (plugin.beforeMutation) {
+      try {
+        const result = await plugin.beforeMutation(ctx, transformed);
+        if (result !== void 0) {
+          transformed = result;
+        }
+      } catch (error) {
+        throw {
+          code: error.code || "INTERNAL",
+          message: error.message || "Plugin error",
+          details: {
+            path: `plugins.${plugin.name}.beforeMutation`,
+            ...error.details || {}
+          }
+        };
+      }
+    }
+  }
+  return transformed;
+}
+async function runAfterMutation(plugins, schema, mutation, result) {
+  let transformed = result;
+  const ctx = { env: "client", schema };
+  for (const plugin of getClientPlugins(plugins)) {
+    if (plugin.afterMutation) {
+      try {
+        await plugin.afterMutation(ctx, mutation, transformed);
+      } catch (error) {
+        console.error(`Plugin ${plugin.name}.afterMutation failed:`, error);
+      }
+    }
+  }
+  return transformed;
+}
+
+// src/query.ts
+async function executeQuery(remote, q, storage, plugins = [], schema) {
+  const transformedQuery = schema ? await runBeforeQuery(plugins, schema, q) : q;
+  if (!storage) {
+    const response2 = await remote.query(transformedQuery);
+    const result2 = unwrapRemoteSuccess(response2);
+    return schema ? runAfterQuery(plugins, schema, transformedQuery, result2) : result2;
+  }
+  if (Array.isArray(transformedQuery)) {
+    const response2 = await remote.query(transformedQuery);
+    const result2 = unwrapRemoteSuccess(response2);
+    return schema ? runAfterQuery(plugins, schema, transformedQuery, result2) : result2;
+  }
+  const query = transformedQuery;
+  const resource = query.resource;
+  if (resource) {
+    const hydrationState = await storage.getHydrationState(resource);
+    if (hydrationState === "ready") {
+      const result2 = await executeLocalQuery(storage, query);
+      return schema ? runAfterQuery(plugins, schema, query, result2) : result2;
+    }
+  }
+  const response = await remote.query(transformedQuery);
+  const result = unwrapRemoteSuccess(response);
+  return schema ? runAfterQuery(plugins, schema, transformedQuery, result) : result;
+}
+
+// src/offline/mutate.ts
+async function handleOfflineMutation(storage, mutation, timestampMs) {
+  const clientId = mutation.clientId;
+  const mutationId = mutation.mutationId;
+  const resource = mutation.resource;
+  const id = mutation.id;
+  try {
+    await storage.changelogAppend({
+      clientId,
+      mutationId,
+      mutation,
+      timestampMs
+    });
+  } catch (err) {
+    throw err;
+  }
+  const operation = mutation.operation;
+  const record = mutation.record || {};
+  if (operation === "delete") {
+    await storage.deleteRecord(resource, id);
+  } else if (operation === "merge") {
+    const existing = await storage.getRecord(resource, id);
+    const merged = existing ? { ...existing, ...record } : { ...record, id };
+    merged.id = id;
+    await storage.upsertRecord(resource, merged);
+  } else if (operation === "insert" || operation === "replace") {
+    const toWrite = { ...record, id };
+    await storage.upsertRecord(resource, toWrite);
+  }
+  return {
+    ok: true,
+    mutationId,
+    affectedIds: [id],
+    deduped: false
+    // local apply is fresh
+  };
+}
+
+// src/mutate.ts
+async function executeMutation(remote, eventBus, getTimestamp, m, storage, plugins = [], schema) {
+  const transformedMutation = schema ? await runBeforeMutation(plugins, schema, m) : m;
+  let result;
+  let fromOfflineFallback = false;
+  try {
+    const response = await remote.mutation(transformedMutation);
+    result = unwrapRemoteSuccess(response);
+    result = schema ? await runAfterMutation(plugins, schema, transformedMutation, result) : result;
+  } catch (err) {
+    if (!Array.isArray(transformedMutation)) {
+      emitRejectionForError(
+        eventBus,
+        getTimestamp,
+        transformedMutation,
+        err
+      );
+    } else {
+      for (const mut of transformedMutation) {
+        emitRejectionForError(eventBus, getTimestamp, mut, err);
+      }
+    }
+    if (storage && !Array.isArray(m) && isTransportError(err)) {
+      try {
+        result = await handleOfflineMutation(
+          storage,
+          m,
+          getTimestamp()
+        );
+        fromOfflineFallback = true;
+      } catch (offlineErr) {
+        throw offlineErr;
+      }
+    } else {
+      throw err;
+    }
+  }
+  if (!Array.isArray(m)) {
+    emitMutationEvents(eventBus, getTimestamp, m, result);
+    return result;
+  }
+  const mutations = m;
+  const results = result;
+  for (let i = 0; i < mutations.length; i++) {
+    emitMutationEvents(eventBus, getTimestamp, mutations[i], results[i]);
+  }
+  return results;
+}
+function emitMutationEvents(eventBus, getTimestamp, mutation, result) {
+  const action = mutation.operation;
+  let fields;
+  if (mutation.operation !== "delete" && mutation.record) {
+    fields = Object.keys(mutation.record).filter((k) => k !== "id").sort();
+  }
+  const baseEvent = {
+    resource: mutation.resource,
+    ids: Array.isArray(mutation.id) ? mutation.id : [mutation.id],
+    mutationId: mutation.mutationId,
+    clientId: mutation.clientId,
+    timestampMs: getTimestamp(),
+    action,
+    // NEW: CLIENT-EVENT-001
+    fields
+    // NEW: CLIENT-EVENT-001
+  };
+  if (result.ok) {
+    eventBus.emit({
+      type: "mutation_applied",
+      ...baseEvent
+    });
+  } else {
+    const errorContext = result.errors?.[0] || {
+      code: "UNKNOWN",
+      message: "Mutation failed",
+      path: "$"
+    };
+    eventBus.emit({
+      type: "mutation_rejected",
+      ...baseEvent,
+      context: errorContext
+    });
+  }
+}
+function emitRejectionForError(eventBus, getTimestamp, mutation, error) {
+  const action = mutation.operation;
+  let fields;
+  if (mutation.operation !== "delete" && mutation.record) {
+    fields = Object.keys(mutation.record).filter((k) => k !== "id").sort();
+  }
+  const errorContext = {
+    code: error.code || "INTERNAL",
+    message: error.message || "Remote error",
+    path: error.path || "$"
+  };
+  eventBus.emit({
+    type: "mutation_rejected",
+    resource: mutation.resource,
+    ids: Array.isArray(mutation.id) ? mutation.id : [mutation.id],
+    mutationId: mutation.mutationId,
+    clientId: mutation.clientId,
+    timestampMs: getTimestamp(),
+    action,
+    fields,
+    context: errorContext
+  });
+}
+
+// src/transact.ts
+async function executeTransact(remote, payload) {
+  const response = await remote.transact(payload);
+  return unwrapRemoteSuccess(response);
+}
+
+// src/signals/querySignal.ts
+var import_core = require("@datafn/core");
+var SignalRegistry = class {
+  constructor(client, eventBus) {
+    this.signals = /* @__PURE__ */ new Map();
+    this.client = client;
+    this.eventBus = eventBus;
+  }
+  getSignal(fullQuery) {
+    const key = (0, import_core.dfqlKey)(fullQuery);
+    if (this.signals.has(key)) {
+      return this.signals.get(key);
+    }
+    const signal = createQuerySignal(this.client, this.eventBus, fullQuery);
+    this.signals.set(key, signal);
+    return signal;
+  }
+};
+function createQuerySignal(client, eventBus, fullQuery) {
+  let currentValue;
+  let status = "idle";
+  const subscribers = /* @__PURE__ */ new Set();
+  let inFlight = false;
+  let queuedRefresh = false;
+  const resource = fullQuery.resource;
+  const fetchQuery = async (isRefresh = false) => {
+    if (inFlight) {
+      if (isRefresh) {
+        queuedRefresh = true;
+      }
+      return;
+    }
+    inFlight = true;
+    queuedRefresh = false;
+    try {
+      const result = await client.query(fullQuery);
+      currentValue = result;
+      status = "idle";
+      if (!isRefresh || currentValue !== void 0) {
+        subscribers.forEach((fn) => fn(currentValue));
+      }
+    } catch (error) {
+      if (!isRefresh) {
+        status = "error";
+        throw error;
+      }
+    } finally {
+      inFlight = false;
+      if (queuedRefresh) {
+        queuedRefresh = false;
+        fetchQuery(true);
+      }
+    }
+  };
+  eventBus.subscribe((event) => {
+    if (event.type === "mutation_applied" && event.resource === resource) {
+      fetchQuery(true);
+    }
+  });
+  return {
+    subscribe(fn) {
+      subscribers.add(fn);
+      if (subscribers.size === 1 && status === "idle" && currentValue === void 0) {
+        fetchQuery(false).catch(() => {
+        });
+      } else if (currentValue !== void 0) {
+        fn(currentValue);
+      }
+      return () => {
+        subscribers.delete(fn);
+      };
+    },
+    get() {
+      return currentValue;
+    }
+  };
+}
+
+// src/sync/apply.ts
+async function applyCloneResult(storage, result) {
+  if (!result.ok) {
+    return;
+  }
+  const { data, cursors } = result;
+  for (const [resource, records] of Object.entries(data)) {
+    await storage.setHydrationState(resource, "hydrating");
+    for (const record of records) {
+      await storage.upsertRecord(resource, record);
+    }
+    const cursor = cursors[resource];
+    if (cursor !== void 0) {
+      await storage.setCursor(resource, cursor);
+    }
+    await storage.setHydrationState(resource, "ready");
+  }
+}
+async function applyPullResult(storage, result) {
+  if (!result.ok) {
+    return;
+  }
+  const { records, deleted, cursors } = result;
+  for (const [resource, resourceRecords] of Object.entries(records)) {
+    for (const record of resourceRecords) {
+      await storage.upsertRecord(resource, record);
+    }
+  }
+  for (const [resource, deletedIds] of Object.entries(deleted)) {
+    for (const id of deletedIds) {
+      await storage.deleteRecord(resource, id);
+    }
+  }
+  for (const [resource, newCursor] of Object.entries(cursors)) {
+    await setCursorMonotonically(storage, resource, newCursor);
+  }
+}
+async function setCursorMonotonically(storage, resource, newCursor) {
+  const existingCursor = await storage.getCursor(resource);
+  if (existingCursor === null) {
+    await storage.setCursor(resource, newCursor);
+    return;
+  }
+  const existingSeq = parseInt(existingCursor, 10);
+  const newSeq = parseInt(newCursor, 10);
+  if (newSeq > existingSeq) {
+    await storage.setCursor(resource, newCursor);
+  }
+}
+
+// src/sync.ts
+function createSyncFacade(remote, storage) {
+  const callSyncMethod = async (methodName, payload) => {
+    const method = remote[methodName];
+    if (typeof method !== "function") {
+      throw createClientError(
+        "TRANSPORT_ERROR",
+        `Transport error: remote method missing: ${methodName}`,
+        { path: `sync.${methodName}` }
+      );
+    }
+    const response = await method.call(remote, payload);
+    return unwrapRemoteSuccess(response);
+  };
+  return {
+    async seed(payload) {
+      return callSyncMethod("seed", payload);
+    },
+    async clone(payload) {
+      const result = await callSyncMethod("clone", payload);
+      if (storage) {
+        await applyCloneResult(storage, result);
+      }
+      return result;
+    },
+    async pull(payload) {
+      const result = await callSyncMethod("pull", payload);
+      if (storage) {
+        await applyPullResult(storage, result);
+      }
+      return result;
+    },
+    async push(payload) {
+      return callSyncMethod("push", payload);
+    }
+  };
+}
+
+// src/client.ts
+function createDatafnClient(config) {
+  const validationResult = (0, import_core2.validateSchema)(config.schema);
+  if (!validationResult.ok) {
+    createClientError(
+      validationResult.error.code,
+      validationResult.error.message,
+      validationResult.error.details
+    );
+  }
+  const schema = validationResult.result;
+  const eventBus = new EventBus();
+  const getTimestamp = config.getTimestamp || (() => Date.now());
+  const RESERVED_KEYS = /* @__PURE__ */ new Set(["then", "toJSON", "inspect"]);
+  const client = {
+    table: null,
+    // Will be set below
+    /**
+     * Execute a query (CLIENT-QUERY-001, CLIENT-OFFLINE-QUERY-001)
+     */
+    async query(q) {
+      return executeQuery(
+        config.remote,
+        q,
+        config.storage,
+        config.plugins || [],
+        schema
+      );
+    },
+    /**
+     * Sync facade (CLIENT-SYNC-001, CLIENT-SYNC-APPLY-001)
+     */
+    sync: createSyncFacade(config.remote, config.storage),
+    /**
+     * Execute a transaction (CLIENT-TX-001)
+     */
+    async transact(payload) {
+      return executeTransact(config.remote, payload);
+    },
+    /**
+     * Execute a mutation (CLIENT-MUT-001, CLIENT-OFFLINE-MUT-001)
+     */
+    async mutate(mutation) {
+      return executeMutation(
+        config.remote,
+        eventBus,
+        getTimestamp,
+        mutation,
+        config.storage,
+        config.plugins || [],
+        schema
+      );
+    },
+    /**
+     * Subscribe to events
+     */
+    subscribe(handler, filter) {
+      return eventBus.subscribe(handler, filter);
+    }
+  };
+  const signalRegistry = new SignalRegistry(client, eventBus);
+  const registry = new TableRegistry(schema, client, signalRegistry);
+  client.table = (name) => registry.getTable(name);
+  return new Proxy(client, {
+    get(target, prop) {
+      if (typeof prop === "string" && RESERVED_KEYS.has(prop)) {
+        return void 0;
+      }
+      if (prop in target) {
+        return target[prop];
+      }
+      if (typeof prop === "string") {
+        return registry.getTable(prop);
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/adapters/memoryStorage.ts
+var MemoryStorageAdapter = class {
+  constructor() {
+    this.records = /* @__PURE__ */ new Map();
+    this.joinRows = /* @__PURE__ */ new Map();
+    this.cursors = /* @__PURE__ */ new Map();
+    this.hydration = /* @__PURE__ */ new Map();
+    this.changelog = [];
+    this.changelogSeq = 1;
+  }
+  // --- Records ---
+  async getRecord(resource, id) {
+    const table = this.records.get(resource);
+    return table?.get(id) || null;
+  }
+  async listRecords(resource) {
+    const table = this.records.get(resource);
+    if (!table) return [];
+    return Array.from(table.values()).sort((a, b) => {
+      const idA = a.id || "";
+      const idB = b.id || "";
+      return idA < idB ? -1 : idA > idB ? 1 : 0;
+    });
+  }
+  async upsertRecord(resource, record) {
+    if (!this.records.has(resource)) {
+      this.records.set(resource, /* @__PURE__ */ new Map());
+    }
+    const id = record.id;
+    if (!id) throw new Error("Record missing id");
+    this.records.get(resource).set(id, record);
+  }
+  async deleteRecord(resource, id) {
+    const table = this.records.get(resource);
+    if (table) {
+      table.delete(id);
+    }
+  }
+  // --- Join Rows ---
+  async listJoinRows(relationKey) {
+    const table = this.joinRows.get(relationKey);
+    if (!table) return [];
+    return Array.from(table.values()).sort((a, b) => {
+      const keyA = `${a.from}:${a.to}`;
+      const keyB = `${b.from}:${b.to}`;
+      return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+    });
+  }
+  async upsertJoinRow(relationKey, row) {
+    if (!this.joinRows.has(relationKey)) {
+      this.joinRows.set(relationKey, /* @__PURE__ */ new Map());
+    }
+    const key = `${row.from}:${row.to}`;
+    this.joinRows.get(relationKey).set(key, row);
+  }
+  async deleteJoinRow(relationKey, from, to) {
+    const table = this.joinRows.get(relationKey);
+    if (table) {
+      table.delete(`${from}:${to}`);
+    }
+  }
+  // --- Sync State ---
+  async getCursor(resource) {
+    return this.cursors.get(resource) || null;
+  }
+  async setCursor(resource, cursor) {
+    this.cursors.set(resource, cursor);
+  }
+  async getHydrationState(resource) {
+    return this.hydration.get(resource) || "notStarted";
+  }
+  async setHydrationState(resource, state) {
+    this.hydration.set(resource, state);
+  }
+  // --- Changelog ---
+  async changelogAppend(entry) {
+    const existing = this.changelog.find(
+      (e) => e.clientId === entry.clientId && e.mutationId === entry.mutationId
+    );
+    if (existing) {
+      return existing;
+    }
+    const newEntry = {
+      ...entry,
+      seq: this.changelogSeq++
+    };
+    this.changelog.push(newEntry);
+    return newEntry;
+  }
+  async changelogList(options = {}) {
+    const limit = options.limit || 100;
+    return this.changelog.slice(0, limit);
+  }
+  async changelogAck(options) {
+    this.changelog = this.changelog.filter((e) => e.seq > options.throughSeq);
+  }
+  // Test helper to clear state
+  clear() {
+    this.records.clear();
+    this.joinRows.clear();
+    this.cursors.clear();
+    this.hydration.clear();
+    this.changelog = [];
+    this.changelogSeq = 1;
+  }
+};
+
+// src/adapters/indexedDbStorage.ts
+var DB_NAME = "datafn_client_db";
+var DB_VERSION = 1;
+var IndexedDbStorageAdapter = class {
+  constructor(dbName = DB_NAME) {
+    this.dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, DB_VERSION);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains("records")) {
+          const store = db.createObjectStore("records", {
+            keyPath: ["resource", "id"]
+          });
+          store.createIndex("by_resource", "resource", { unique: false });
+        }
+        if (!db.objectStoreNames.contains("join_rows")) {
+          const store = db.createObjectStore("join_rows", {
+            keyPath: ["relationKey", "from", "to"]
+          });
+          store.createIndex("by_relation", "relationKey", { unique: false });
+        }
+        if (!db.objectStoreNames.contains("meta")) {
+          db.createObjectStore("meta", { keyPath: ["type", "key"] });
+        }
+        if (!db.objectStoreNames.contains("changelog")) {
+          const store = db.createObjectStore("changelog", {
+            keyPath: "seq",
+            autoIncrement: true
+          });
+          store.createIndex("by_client_mutation", ["clientId", "mutationId"], {
+            unique: true
+          });
+        }
+      };
+    });
+  }
+  async getStore(storeName, mode) {
+    const db = await this.dbPromise;
+    return db.transaction(storeName, mode).objectStore(storeName);
+  }
+  // --- Records ---
+  async getRecord(resource, id) {
+    const store = await this.getStore("records", "readonly");
+    return new Promise((resolve, reject) => {
+      const request = store.get([resource, id]);
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async listRecords(resource) {
+    const store = await this.getStore("records", "readonly");
+    const index = store.index("by_resource");
+    return new Promise((resolve, reject) => {
+      const range = IDBKeyRange.bound([resource, ""], [resource, "\uFFFF"]);
+      const request = store.getAll(range);
+      request.onsuccess = () => resolve(request.result || []);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async upsertRecord(resource, record) {
+    const store = await this.getStore("records", "readwrite");
+    return new Promise((resolve, reject) => {
+      const recordWithKey = { ...record, resource };
+      const request = store.put(recordWithKey);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async deleteRecord(resource, id) {
+    const store = await this.getStore("records", "readwrite");
+    return new Promise((resolve, reject) => {
+      const request = store.delete([resource, id]);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  // --- Join Rows ---
+  async listJoinRows(relationKey) {
+    const store = await this.getStore("join_rows", "readonly");
+    const range = IDBKeyRange.bound(
+      [relationKey, "", ""],
+      [relationKey, "\uFFFF", "\uFFFF"]
+    );
+    return new Promise((resolve, reject) => {
+      const request = store.getAll(range);
+      request.onsuccess = () => resolve(request.result || []);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async upsertJoinRow(relationKey, row) {
+    const store = await this.getStore("join_rows", "readwrite");
+    return new Promise((resolve, reject) => {
+      const rowWithKey = { ...row, relationKey };
+      const request = store.put(rowWithKey);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async deleteJoinRow(relationKey, from, to) {
+    const store = await this.getStore("join_rows", "readwrite");
+    return new Promise((resolve, reject) => {
+      const request = store.delete([relationKey, from, to]);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  // --- Sync State ---
+  async getCursor(resource) {
+    const store = await this.getStore("meta", "readonly");
+    return new Promise((resolve, reject) => {
+      const request = store.get(["cursor", resource]);
+      request.onsuccess = () => resolve(request.result?.value || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async setCursor(resource, cursor) {
+    const store = await this.getStore("meta", "readwrite");
+    return new Promise((resolve, reject) => {
+      const request = store.put({
+        type: "cursor",
+        key: resource,
+        value: cursor
+      });
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async getHydrationState(resource) {
+    const store = await this.getStore("meta", "readonly");
+    return new Promise((resolve, reject) => {
+      const request = store.get(["hydration", resource]);
+      request.onsuccess = () => resolve(request.result?.value || "notStarted");
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async setHydrationState(resource, state) {
+    const store = await this.getStore("meta", "readwrite");
+    return new Promise((resolve, reject) => {
+      const request = store.put({
+        type: "hydration",
+        key: resource,
+        value: state
+      });
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  // --- Changelog ---
+  async changelogAppend(entry) {
+    const store = await this.getStore("changelog", "readwrite");
+    const index = store.index("by_client_mutation");
+    const existing = await new Promise(
+      (resolve, reject) => {
+        const request = index.get([entry.clientId, entry.mutationId]);
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      }
+    );
+    if (existing) {
+      return existing;
+    }
+    return new Promise((resolve, reject) => {
+      const request = store.add(entry);
+      request.onsuccess = () => {
+        const seq = request.result;
+        resolve({ ...entry, seq });
+      };
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async changelogList(options = {}) {
+    const store = await this.getStore("changelog", "readonly");
+    return new Promise((resolve, reject) => {
+      const limit = options.limit || 100;
+      const request = store.getAll(null, limit);
+      request.onsuccess = () => resolve(request.result || []);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async changelogAck(options) {
+    const store = await this.getStore("changelog", "readwrite");
+    const range = IDBKeyRange.upperBound(options.throughSeq);
+    return new Promise((resolve, reject) => {
+      const request = store.delete(range);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventBus,
+  IndexedDbStorageAdapter,
+  MemoryStorageAdapter,
+  createClientError,
+  createDatafnClient,
+  matchesFilter,
+  unwrapRemoteSuccess
+});
+//# sourceMappingURL=index.cjs.map