zerodrift 1.0.2 → 1.0.4

package/README.md

@@ -2,19 +2,27 @@
 
 [![npm](https://img.shields.io/npm/v/zerodrift.svg)](https://www.npmjs.com/package/zerodrift)
 
-A TypeScript local-first sync engine. Reads are synchronous from an in-memory pool, writes are optimistic, state stays current across tabs and clients via SSE, and everything persists locally so the app survives reloads and works offline. The same engine runs in Node so agents and background workers can hold a live model just like a browser tab.
+**A TypeScript sync engine with an intuitive model API that hides the hard parts of local reads, optimistic writes, offline recovery, and realtime convergence.**
 
-You bring the backend. The client speaks a small three-endpoint protocol that can be implemented in any language. A reference Go backend and Next.js demo live in this repo so you can run the whole loop locally.
+zerodrift lets you work with synced data like normal application state. Components and headless workers read records synchronously, mutate model fields directly, call `save()`, and subscribe with typed React hooks or store APIs. Under that simple surface, the engine does the synchronization work that would otherwise spread across your codebase.
+
+The backend stays yours. Implement bootstrap, transaction, and event-stream endpoints in any stack, or start from the included Go backend and Next.js demo. In the browser, zerodrift persists models and queued writes to IndexedDB; in Node, it can run against memory or a custom storage adapter.
+
+The result is less sync code in every feature. Define models with decorators or schema-as-data, wire the three transport functions, and build against a small, predictable API while browser tabs, clients, and Node processes converge in the background.
+
+The design is inspired by Linear's sync engine; see [Acknowledgments](#acknowledgments) for prior art and attribution.
 
 ## What you get
 
-- **Local-first reads**: every read hits an in-memory `ObjectPool` first.
-- **Optimistic writes**: model changes update the UI immediately, then reconcile with server deltas.
-- **Realtime sync**: tabs and clients stay current over SSE, without polling.
-- **Offline persistence**: IndexedDB stores models and queued transactions in the browser.
-- **Two authoring paths**: decorator classes or schema-as-data via `defineSchema(...)`.
-- **React and headless runtimes**: use hooks in React, or run `StoreManager` directly in Node, CLIs, and agents.
-- **Bring your own backend**: implement bootstrap, transaction, and SSE endpoints in the stack you already use.
+- **A small API for synced data**: read records synchronously, mutate model fields directly, call `save()`, or use typed store namespaces generated from a schema.
+- **App logic without cache choreography**: fetching, invalidation, optimistic updates, reconnects, offline replay, and conflict rebasing live in the engine instead of every screen.
+- **Optimistic writes with real recovery**: local changes update immediately, batch into transaction POSTs, persist through reloads, and reconcile when matching server deltas arrive.
+- **Relationships that stay live**: references, inverse collections, owned collections, and indexed lookups update as records hydrate, load lazily, or arrive over SSE.
+- **Schema or class models**: use decorators (`@ClientModel`, `@Property`, `@Reference`) or schema-as-data (`defineSchema(...)`, `entityFromZod(...)`) without `reflect-metadata`.
+- **Memory you can shape**: choose per-model `LoadStrategy` values for eager data, lazy tables, partial index-backed loading, local-only records, or ephemeral SSE-fed state.
+- **Undo/redo built into the transaction layer**: track field-level changes, group atomic multi-model edits, and include custom remote actions in the same undo stack.
+- **React, browser, or headless Node**: use `<SyncProvider>` and typed hooks in React, or run `StoreManager` directly in agents, workers, CLIs, and tests.
+- **Your backend, your stack**: implement three HTTP endpoints in any language, with a reference Go backend and Next.js demo included.
 
 ## Install
 
@@ -33,12 +41,12 @@ Decorator path: enable `experimentalDecorators` in your `tsconfig.json` (or the
 
 ## Import paths
 
-| Import | Use it for |
-|---|---|
-| `zerodrift` | `StoreManager`, `BaseModel`, decorators, `MemoryAdapter`, relation field types (`RefCollection`/`BackRef`/`OwnedRefs`), and the config / error / sync types. The curated, stable surface. |
-| `zerodrift/schema` | `defineSchema`, `entityFromZod`, field builders, links, extensions, and typed `store.<entity>.*` APIs. |
-| `zerodrift/react` | `<SyncProvider>` and React hooks: `useRecord`, `useRecords`, `useRecordsByIndex`, `useRelation`, `useBatch`, `useUndoRedo`, `useBootstrapStatus`. |
-| `zerodrift/internal` | Engine machinery (`ObjectPool`, `TransactionQueue`, `SyncConnection`, `ModelRegistry`, …) for tooling/tests. **No stability promise** — may change between releases. |
+| Import               | Use it for                                                                                                                                                                                |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `zerodrift`          | `StoreManager`, `BaseModel`, decorators, `MemoryAdapter`, relation field types (`RefCollection`/`BackRef`/`OwnedRefs`), and the config / error / sync types. The curated, stable surface. |
+| `zerodrift/schema`   | `defineSchema`, `entityFromZod`, field builders, links, extensions, and typed `store.<entity>.*` APIs.                                                                                    |
+| `zerodrift/react`    | `<SyncProvider>` and React hooks: `useRecord`, `useRecords`, `useRecordsByIndex`, `useRelation`, `useBatch`, `useUndoRedo`, `useBootstrapStatus`.                                         |
+| `zerodrift/internal` | Engine machinery (`ObjectPool`, `TransactionQueue`, `SyncConnection`, `ModelRegistry`, …) for tooling/tests. **No stability promise** — may change between releases.                      |
 
 ## Define your models
 
@@ -250,11 +258,11 @@ See [agent-docs/09-headless-and-agents.md](agent-docs/09-headless-and-agents.md)
 
 The client needs three endpoints:
 
-| Endpoint | Purpose |
-|---|---|
-| `GET /api/bootstrap` | Fetch initial or partial model data. |
-| `POST /api/transactions` | Accept queued client mutations. |
-| `GET /api/events` | Stream delta packets over SSE. |
+| Endpoint                 | Purpose                              |
+| ------------------------ | ------------------------------------ |
+| `GET /api/bootstrap`     | Fetch initial or partial model data. |
+| `POST /api/transactions` | Accept queued client mutations.      |
+| `GET /api/events`        | Stream delta packets over SSE.       |
 
 Bootstrap returns records grouped by model name:
 
@@ -317,7 +325,7 @@ The client reconnects with `?lastSyncId=<id>` so the server can replay missed ev
 ## Run the demo
 
 A reference Go backend + Next.js app that exercises the full sync loop
-locally live in [`examples/`](examples/). See [examples/README.md](examples/README.md)
+locally live in [examples/](examples/). See [examples/README.md](examples/README.md)
 for the one-command-each setup:
 
 ```bash

package/dist/core/BaseModel.d.ts

@@ -13,8 +13,8 @@
  *   - BackRef for @BackReference properties
  * These are stored on __collections and __backRefs, read by the decorator getters.
  */
-import { type PropertyChange, type IObjectPool, type IStoreManager } from "./types";
-import { LazyCollectionBase, BackRef } from "./LazyCollection";
+import { type PropertyChange, type IObjectPool, type IStoreManager } from "./types.js";
+import { LazyCollectionBase, BackRef } from "./LazyCollection.js";
 import { type IObservableValue } from "mobx";
 export declare class BaseModel {
     id: string;

package/dist/core/BaseModel.js

@@ -13,10 +13,10 @@
  *   - BackRef for @BackReference properties
  * These are stored on __collections and __backRefs, read by the decorator getters.
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { PropertyType, DEFAULT_TRANSIENT_INDEX_DEPTH, } from "./types";
-import { RefCollection, BackRef } from "./LazyCollection";
-import { OwnedRefs } from "./LazyOwnedCollection";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { PropertyType, DEFAULT_TRANSIENT_INDEX_DEPTH, } from "./types.js";
+import { RefCollection, BackRef } from "./LazyCollection.js";
+import { OwnedRefs } from "./LazyOwnedCollection.js";
 import { action, computed, observable, reaction, runInAction, } from "mobx";
 // The four PropertyTypes that have MobX boxes and direct setters — the "flat scalar" fields.
 // Used by makeModelObservable (to create boxes) and assign() (to filter writable keys).

package/dist/core/BaseSSEConnection.d.ts

@@ -1,4 +1,4 @@
-import { type EngineErrorContext } from "./types";
+import { type EngineErrorContext } from "./types.js";
 export interface SSEClient {
     onmessage: ((event: {
         data: string;

package/dist/core/BaseSSEConnection.js

@@ -1,4 +1,4 @@
-import { toError } from "./types";
+import { toError } from "./types.js";
 export const createBrowserSSEFactory = (init) => (url) => new EventSource(url, init);
 export class BaseSSEConnection {
     constructor(url, sseClientFactory = createBrowserSSEFactory(), reportError) {

package/dist/core/CompoundIndexFetcher.d.ts

@@ -14,8 +14,8 @@
  * Adopters without server JOIN support leave the flag unset; the engine
  * fans out per-parent (existing behavior).
  */
-import type { IndexBatchFetcher, IndexQuery } from "./BatchModelLoader";
-import { type ObjectPool } from "./ObjectPool";
+import type { IndexBatchFetcher, IndexQuery } from "./BatchModelLoader.js";
+import { type ObjectPool } from "./ObjectPool.js";
 /** Switch to a compound fetch only when at least this many pending
  * requests share a single parent FK value. Below this, the per-parent
  * fan-out wins because the compound response would over-fetch. */

package/dist/core/CompoundIndexFetcher.js

@@ -14,9 +14,9 @@
  * Adopters without server JOIN support leave the flag unset; the engine
  * fans out per-parent (existing behavior).
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { readFk } from "./ObjectPool";
-import { PropertyType } from "./types";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { readFk } from "./ObjectPool.js";
+import { PropertyType } from "./types.js";
 /** Switch to a compound fetch only when at least this many pending
  * requests share a single parent FK value. Below this, the per-parent
  * fan-out wins because the compound response would over-fetch. */

package/dist/core/Database.js

@@ -15,7 +15,7 @@
  *   - Partial: DB exists with valid data, just need delta since lastSyncId
  *   - Local: DB exists, no server contact needed (offline start)
  */
-import { ModelRegistry } from "./ModelRegistry";
+import { ModelRegistry } from "./ModelRegistry.js";
 export var BootstrapType;
 (function (BootstrapType) {
     BootstrapType["Full"] = "full";

package/dist/core/LazyCollection.d.ts

@@ -28,8 +28,8 @@
  *   // or via hook:
  *   const { data, isLoading } = useRelation(team?.issues);
  */
-import type { BaseModel } from "./BaseModel";
-import type { CoveringPath } from "./types";
+import type { BaseModel } from "./BaseModel.js";
+import type { CoveringPath } from "./types.js";
 export declare enum CollectionState {
     /** Never accessed — hydrate() computed the index values but no load yet. */
     Idle = "idle",

package/dist/core/LazyCollection.js

@@ -29,7 +29,7 @@
  *   const { data, isLoading } = useRelation(team?.issues);
  */
 import { observable, runInAction, makeObservable } from "mobx";
-import { readFk } from "./ObjectPool";
+import { readFk } from "./ObjectPool.js";
 /** Walk a `CoveringPath` from `parent` through the pool, returning the
  * leaf FK value or null if any link is missing. Depth-1 paths are a single
  * `readFk(parent, hops[0].fk)`. Deeper paths use intermediate

package/dist/core/LazyOwnedCollection.d.ts

@@ -15,8 +15,8 @@
  *   @OwnedCollection("Issue", { idsField: "issueIds" })
  *   public issues: OwnedRefs<Issue>;
  */
-import type { BaseModel } from "./BaseModel";
-import { LazyCollectionBase } from "./LazyCollection";
+import type { BaseModel } from "./BaseModel.js";
+import { LazyCollectionBase } from "./LazyCollection.js";
 export declare class OwnedRefs<T extends BaseModel = BaseModel> extends LazyCollectionBase<T> {
     /** Live getter — reads the current IDs array from the parent model each call. */
     private idsGetter;

package/dist/core/LazyOwnedCollection.js

@@ -16,7 +16,7 @@
  *   public issues: OwnedRefs<Issue>;
  */
 import { runInAction } from "mobx";
-import { LazyCollectionBase, CollectionState } from "./LazyCollection";
+import { LazyCollectionBase, CollectionState } from "./LazyCollection.js";
 export class OwnedRefs extends LazyCollectionBase {
     constructor(referencedModelName, idsGetter) {
         super(referencedModelName);

package/dist/core/MemoryAdapter.d.ts

@@ -8,7 +8,7 @@
  * storage in a server environment, implement StorageAdapter with your own
  * SQLite / Redis / file-system backend.
  */
-import { BootstrapType, type DatabaseMeta, type PartialIndexEntry, type StorageAdapter, type SyncActionHeader } from "./Database";
+import { BootstrapType, type DatabaseMeta, type PartialIndexEntry, type StorageAdapter, type SyncActionHeader } from "./Database.js";
 export declare class MemoryAdapter implements StorageAdapter {
     private meta;
     private models;

package/dist/core/MemoryAdapter.js

@@ -8,7 +8,7 @@
  * storage in a server environment, implement StorageAdapter with your own
  * SQLite / Redis / file-system backend.
  */
-import { BootstrapType, LoadedModelsTracker, diffModelVersions, currentModelVersions, } from "./Database";
+import { BootstrapType, LoadedModelsTracker, diffModelVersions, currentModelVersions, } from "./Database.js";
 export class MemoryAdapter {
     constructor() {
         this.meta = null;

package/dist/core/ModelRegistry.d.ts

@@ -8,7 +8,7 @@
  * Also computes a schemaHash — a fingerprint of all models and their properties.
  * If the hash changes between sessions, the local IndexedDB needs a migration.
  */
-import { type ModelMeta, type PropertyMeta, type CoveringPath } from "./types";
+import { type ModelMeta, type PropertyMeta, type CoveringPath } from "./types.js";
 declare class ModelRegistryImpl {
     private models;
     private cachedHash;

package/dist/core/ModelRegistry.js

@@ -8,8 +8,8 @@
  * Also computes a schemaHash — a fingerprint of all models and their properties.
  * If the hash changes between sessions, the local IndexedDB needs a migration.
  */
-import { hashString } from "./hash";
-import { LoadStrategy, PropertyType, } from "./types";
+import { hashString } from "./hash.js";
+import { LoadStrategy, PropertyType, } from "./types.js";
 class ModelRegistryImpl {
     constructor() {
         this.models = new Map();

package/dist/core/ModelStream.d.ts

@@ -3,9 +3,9 @@
  * Writes to IDB and upserts into the ObjectPool — no sync state management.
  * Ephemeral models skip IDB and are only held in the pool.
  */
-import type { StorageAdapter } from "./Database";
-import { ObjectPool } from "./ObjectPool";
-import { BaseSSEConnection, type SSEClientFactory, type SSEErrorReporter } from "./BaseSSEConnection";
+import type { StorageAdapter } from "./Database.js";
+import { ObjectPool } from "./ObjectPool.js";
+import { BaseSSEConnection, type SSEClientFactory, type SSEErrorReporter } from "./BaseSSEConnection.js";
 export interface ModelUpdate {
     modelName: string;
     modelId: string;

package/dist/core/ModelStream.js

@@ -3,9 +3,9 @@
  * Writes to IDB and upserts into the ObjectPool — no sync state management.
  * Ephemeral models skip IDB and are only held in the pool.
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { BaseSSEConnection, } from "./BaseSSEConnection";
-import { LoadStrategy } from "./types";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { BaseSSEConnection, } from "./BaseSSEConnection.js";
+import { LoadStrategy } from "./types.js";
 export class ModelStream extends BaseSSEConnection {
     constructor(url, database, pool, onStatusChange, sseClientFactory, transform, reportError) {
         super(url, sseClientFactory, reportError);

package/dist/core/ObjectPool.d.ts

@@ -11,8 +11,8 @@
  *   adds, updates, or removes an instance of that type, all subscribers
  *   are notified and their components re-render.
  */
-import type { BaseModel } from "./BaseModel";
-import { type ModelMeta } from "./types";
+import type { BaseModel } from "./BaseModel.js";
+import { type ModelMeta } from "./types.js";
 type Listener = () => void;
 /**
  * Read a dynamic property off a model instance. The single bridge between

package/dist/core/ObjectPool.js

@@ -12,8 +12,8 @@
  *   are notified and their components re-render.
  */
 import { createAtom, runInAction } from "mobx";
-import { ModelRegistry } from "./ModelRegistry";
-import { PropertyType } from "./types";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { PropertyType } from "./types.js";
 /**
  * Read a dynamic property off a model instance. The single bridge between
  * the typed `BaseModel` shape and the index-string access we need for

package/dist/core/Store.d.ts

@@ -6,10 +6,10 @@
  *   - PartialStore for partial models (on demand)
  *   - EphemeralStore for ephemeral models (pool-only, never persisted)
  */
-import type { BaseModel } from "./BaseModel";
-import type { StorageAdapter } from "./Database";
-import { ObjectPool } from "./ObjectPool";
-import { type ModelMeta } from "./types";
+import type { BaseModel } from "./BaseModel.js";
+import type { StorageAdapter } from "./Database.js";
+import { ObjectPool } from "./ObjectPool.js";
+import { type ModelMeta } from "./types.js";
 export declare abstract class ModelStore {
     protected meta: ModelMeta;
     protected database: StorageAdapter;

package/dist/core/Store.js

@@ -6,7 +6,7 @@
  *   - PartialStore for partial models (on demand)
  *   - EphemeralStore for ephemeral models (pool-only, never persisted)
  */
-import { LoadStrategy } from "./types";
+import { LoadStrategy } from "./types.js";
 export class ModelStore {
     constructor(meta, database, pool) {
         this.meta = meta;

package/dist/core/StoreManager.d.ts

@@ -18,14 +18,14 @@
  *   storeManager.getOrLoadCollection("Issue", "teamId", teamId)
  *   storeManager.getOrLoadById("DocumentContent", docId)
  */
-import { ObjectPool } from "./ObjectPool";
-import { BootstrapType, type StorageAdapter, type DatabaseMeta, type PartialIndexEntry } from "./Database";
-import { TransactionQueue, type TransactionSender, type UndoableActionHandlers } from "./TransactionQueue";
-import { type DeltaPacket, type SSEClientFactory, type SyncMessageTransform } from "./SyncConnection";
-import { type ModelStreamMessageTransform } from "./ModelStream";
-import { type IndexBatchFetcher } from "./BatchModelLoader";
-import { BaseModel } from "./BaseModel";
-import { BootstrapPhase, type ModelMeta, type PropertyMeta, type PropertyChange, type FieldTransform, type EngineErrorContext, type EngineErrorHandler, type CommitRouteHandler, type OnModelTouchedHandler } from "./types";
+import { ObjectPool } from "./ObjectPool.js";
+import { BootstrapType, type StorageAdapter, type DatabaseMeta, type PartialIndexEntry } from "./Database.js";
+import { TransactionQueue, type TransactionSender, type UndoableActionHandlers } from "./TransactionQueue.js";
+import { type DeltaPacket, type SSEClientFactory, type SyncMessageTransform } from "./SyncConnection.js";
+import { type ModelStreamMessageTransform } from "./ModelStream.js";
+import { type IndexBatchFetcher } from "./BatchModelLoader.js";
+import { BaseModel } from "./BaseModel.js";
+import { BootstrapPhase, type ModelMeta, type PropertyMeta, type PropertyChange, type FieldTransform, type EngineErrorContext, type EngineErrorHandler, type CommitRouteHandler, type OnModelTouchedHandler } from "./types.js";
 /**
  * Thrown when a delete/archive is blocked by an onDelete: "restrict" relationship.
  *
@@ -624,8 +624,8 @@ export declare class StoreManager<TContext = unknown> {
      * draft target's `assign()` doesn't re-trigger a user-facing "first edit".
      * BaseModel guards on `hasModelTouchedHandler` before calling. */
     fireModelTouched(model: BaseModel, modelName: string): void;
-    undo(): Promise<import("./TransactionQueue").UndoResult | null>;
-    redo(): Promise<import("./TransactionQueue").UndoResult | null>;
+    undo(): Promise<import("./TransactionQueue.js").UndoResult | null>;
+    redo(): Promise<import("./TransactionQueue.js").UndoResult | null>;
     /**
      * Run a remote side-effect that returns a `changeLogId`, and record it on
      * the undo stack so the next `undo()` invokes the consumer's

package/dist/core/StoreManager.js

@@ -18,18 +18,18 @@
  *   storeManager.getOrLoadCollection("Issue", "teamId", teamId)
  *   storeManager.getOrLoadById("DocumentContent", docId)
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { DEFAULT_TRANSIENT_INDEX_DEPTH } from "./types";
-import { ObjectPool, prop, readFk } from "./ObjectPool";
-import { Database, BootstrapType, } from "./Database";
-import { FullStore, PartialStore, EphemeralStore, } from "./Store";
-import { TransactionQueue, } from "./TransactionQueue";
-import { SyncConnection, encodeCsvList, createBrowserSSEFactory, } from "./SyncConnection";
-import { ModelStream } from "./ModelStream";
-import { BatchModelLoader } from "./BatchModelLoader";
-import { COMPOUND_FETCH_THRESHOLD, wrapCompoundFetcher, } from "./CompoundIndexFetcher";
-import { BaseModel } from "./BaseModel";
-import { BootstrapPhase, LoadStrategy, PropertyType, toError, } from "./types";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { DEFAULT_TRANSIENT_INDEX_DEPTH } from "./types.js";
+import { ObjectPool, prop, readFk } from "./ObjectPool.js";
+import { Database, BootstrapType, } from "./Database.js";
+import { FullStore, PartialStore, EphemeralStore, } from "./Store.js";
+import { TransactionQueue, } from "./TransactionQueue.js";
+import { SyncConnection, encodeCsvList, createBrowserSSEFactory, } from "./SyncConnection.js";
+import { ModelStream } from "./ModelStream.js";
+import { BatchModelLoader } from "./BatchModelLoader.js";
+import { COMPOUND_FETCH_THRESHOLD, wrapCompoundFetcher, } from "./CompoundIndexFetcher.js";
+import { BaseModel } from "./BaseModel.js";
+import { BootstrapPhase, LoadStrategy, PropertyType, toError, } from "./types.js";
 /**
  * Thrown when a delete/archive is blocked by an onDelete: "restrict" relationship.
  *

package/dist/core/SyncConnection.d.ts

@@ -21,11 +21,11 @@
  *   `BaseModel.hydrate` dispatches FK changes for in-pool models. SyncConnection
  *   only has to mutate the pool; parent collections track changes themselves.
  */
-import type { StorageAdapter } from "./Database";
-import { ObjectPool } from "./ObjectPool";
-import { TransactionQueue } from "./TransactionQueue";
-import { BaseSSEConnection, type SSEClientFactory, type SSEErrorReporter } from "./BaseSSEConnection";
-export { type SSEClient, type SSEClientFactory, type SSEErrorReporter, createBrowserSSEFactory, } from "./BaseSSEConnection";
+import type { StorageAdapter } from "./Database.js";
+import { ObjectPool } from "./ObjectPool.js";
+import { TransactionQueue } from "./TransactionQueue.js";
+import { BaseSSEConnection, type SSEClientFactory, type SSEErrorReporter } from "./BaseSSEConnection.js";
+export { type SSEClient, type SSEClientFactory, type SSEErrorReporter, createBrowserSSEFactory, } from "./BaseSSEConnection.js";
 /**
  * Encode each element then comma-join — the right shape for a list-of-
  * strings inside a URL query parameter or a stable cache key. Commas

package/dist/core/SyncConnection.js

@@ -21,11 +21,11 @@
  *   `BaseModel.hydrate` dispatches FK changes for in-pool models. SyncConnection
  *   only has to mutate the pool; parent collections track changes themselves.
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { LoadStrategy, PropertyType } from "./types";
-import { BaseSSEConnection, } from "./BaseSSEConnection";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { LoadStrategy, PropertyType } from "./types.js";
+import { BaseSSEConnection, } from "./BaseSSEConnection.js";
 // Re-export so existing imports from "@zerodrift/SyncConnection" keep working.
-export { createBrowserSSEFactory, } from "./BaseSSEConnection";
+export { createBrowserSSEFactory, } from "./BaseSSEConnection.js";
 /** How many syncIds back to retain in the SyncAction store before pruning.
  * Covers short offline gaps where a persisted pending tx asks "was my
  * target deleted while I was away?" on next reconnect. */

package/dist/core/Transaction.d.ts

@@ -7,8 +7,8 @@
  * Rebasing (UpdateTransaction): when a delta packet conflicts with our local
  * change, the server value becomes our new baseline and our value is re-applied.
  */
-import type { BaseModel } from "./BaseModel";
-import { TransactionState, type PropertyChange } from "./types";
+import type { BaseModel } from "./BaseModel.js";
+import { TransactionState, type PropertyChange } from "./types.js";
 export declare abstract class BaseTransaction {
     readonly id: `${string}-${string}-${string}-${string}-${string}`;
     readonly modelId: string;

package/dist/core/Transaction.js

@@ -7,7 +7,7 @@
  * Rebasing (UpdateTransaction): when a delta packet conflicts with our local
  * change, the server value becomes our new baseline and our value is re-applied.
  */
-import { TransactionState } from "./types";
+import { TransactionState } from "./types.js";
 export class BaseTransaction {
     constructor(modelId, modelName) {
         this.id = crypto.randomUUID();

package/dist/core/TransactionQueue.d.ts

@@ -12,12 +12,12 @@
  *
  * The undo stack stores "entries" — either a single tx or a batch of txs.
  */
-import type { StorageAdapter } from "./Database";
-import { ObjectPool } from "./ObjectPool";
-import { type EngineErrorContext } from "./types";
-import { BaseTransaction, UpdateTransaction, type UndoableAction } from "./Transaction";
-import { type PropertyChange } from "./types";
-import type { BaseModel } from "./BaseModel";
+import type { StorageAdapter } from "./Database.js";
+import { ObjectPool } from "./ObjectPool.js";
+import { type EngineErrorContext } from "./types.js";
+import { BaseTransaction, UpdateTransaction, type UndoableAction } from "./Transaction.js";
+import { type PropertyChange } from "./types.js";
+import type { BaseModel } from "./BaseModel.js";
 export interface BatchResponse {
     success: boolean;
     lastSyncId: number;

package/dist/core/TransactionQueue.js

@@ -12,10 +12,10 @@
  *
  * The undo stack stores "entries" — either a single tx or a batch of txs.
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { toError } from "./types";
-import { BaseTransaction, UpdateTransaction, CreateTransaction, DeleteTransaction, ArchiveTransaction, } from "./Transaction";
-import { TransactionState } from "./types";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { toError } from "./types.js";
+import { BaseTransaction, UpdateTransaction, CreateTransaction, DeleteTransaction, ArchiveTransaction, } from "./Transaction.js";
+import { TransactionState } from "./types.js";
 const isAction = (e) => !(e instanceof BaseTransaction);
 export class TransactionQueue {
     constructor(database, pool, undoLimit = 100) {

package/dist/core/decorators.d.ts

@@ -15,7 +15,7 @@
  * time. The engine reads that metadata later for serialization, hydration,
  * observability, indexing, and reference resolution.
  */
-import { LoadStrategy } from "./types";
+import { LoadStrategy } from "./types.js";
 export declare function ClientModel(opts?: {
     /**
      * The registry name — what `ModelMeta.name` becomes, what

package/dist/core/decorators.js

@@ -15,10 +15,10 @@
  * time. The engine reads that metadata later for serialization, hydration,
  * observability, indexing, and reference resolution.
  */
-import { ModelRegistry } from "./ModelRegistry";
-import { defineObservableProperty } from "./observability";
-import { PropertyType, } from "./types";
-import { installBackRefAccessor, installCollectionAccessor, installReferenceAccessor, } from "./refAccessors";
+import { ModelRegistry } from "./ModelRegistry.js";
+import { defineObservableProperty } from "./observability.js";
+import { PropertyType, } from "./types.js";
+import { installBackRefAccessor, installCollectionAccessor, installReferenceAccessor, } from "./refAccessors.js";
 const pendingByClass = new WeakMap();
 function getOrCreatePending(ctor) {
     let entry = pendingByClass.get(ctor);

package/dist/core/index.d.ts

@@ -1,16 +1,16 @@
-export { LoadStrategy, PropertyType, BootstrapPhase, TransactionState, } from "./types";
-export { dateSerializer, dateDeserializer } from "./serializers";
-export type { PropertyMeta, ModelMeta, FieldTransform, PropertyChange, CommitIntent, CommitRouteResult, CommitRouteHandler, OnModelTouchedHandler, OnDelete, EngineErrorContext, EngineErrorHandler, } from "./types";
-export { ClientModel, Property, EphemeralProperty, Reference, LazyReference, ReferenceCollection, LazyReferenceCollection, OwnedCollection, LazyOwnedCollection, BackReference, ReferenceArray, Action, Computed, } from "./decorators";
-export { BaseModel } from "./BaseModel";
-export { RefCollection, BackRef, CollectionState } from "./LazyCollection";
-export { OwnedRefs } from "./LazyOwnedCollection";
-export { MemoryAdapter } from "./MemoryAdapter";
-export { BootstrapType } from "./Database";
-export type { DatabaseMeta, StorageAdapter } from "./Database";
-export { StoreManager, RestrictDeleteError } from "./StoreManager";
-export type { BootstrapResponse, BootstrapFetcher, BootstrapFetcherOptions, FetcherContext, StoreManagerConfig, TransportConfig, LoadingConfig, PersistenceConfig, HooksConfig, AdvancedConfig, OnDemandConfig, OnDemandFetcher, OnDemandBatchFetcher, ModelStreamConfig, } from "./StoreManager";
-export type { UndoableAction } from "./Transaction";
-export type { TransactionSender, BatchResponse, UndoableActionHandlers, UndoResult, } from "./TransactionQueue";
-export type { SyncAction, DeltaPacket, SyncMessageTransform, } from "./SyncConnection";
-export type { ModelUpdate, ModelStreamMessageTransform } from "./ModelStream";
+export { LoadStrategy, PropertyType, BootstrapPhase, TransactionState, } from "./types.js";
+export { dateSerializer, dateDeserializer } from "./serializers.js";
+export type { PropertyMeta, ModelMeta, FieldTransform, PropertyChange, CommitIntent, CommitRouteResult, CommitRouteHandler, OnModelTouchedHandler, OnDelete, EngineErrorContext, EngineErrorHandler, } from "./types.js";
+export { ClientModel, Property, EphemeralProperty, Reference, LazyReference, ReferenceCollection, LazyReferenceCollection, OwnedCollection, LazyOwnedCollection, BackReference, ReferenceArray, Action, Computed, } from "./decorators.js";
+export { BaseModel } from "./BaseModel.js";
+export { RefCollection, BackRef, CollectionState } from "./LazyCollection.js";
+export { OwnedRefs } from "./LazyOwnedCollection.js";
+export { MemoryAdapter } from "./MemoryAdapter.js";
+export { BootstrapType } from "./Database.js";
+export type { DatabaseMeta, StorageAdapter } from "./Database.js";
+export { StoreManager, RestrictDeleteError } from "./StoreManager.js";
+export type { BootstrapResponse, BootstrapFetcher, BootstrapFetcherOptions, FetcherContext, StoreManagerConfig, TransportConfig, LoadingConfig, PersistenceConfig, HooksConfig, AdvancedConfig, OnDemandConfig, OnDemandFetcher, OnDemandBatchFetcher, ModelStreamConfig, } from "./StoreManager.js";
+export type { UndoableAction } from "./Transaction.js";
+export type { TransactionSender, BatchResponse, UndoableActionHandlers, UndoResult, } from "./TransactionQueue.js";
+export type { SyncAction, DeltaPacket, SyncMessageTransform, } from "./SyncConnection.js";
+export type { ModelUpdate, ModelStreamMessageTransform } from "./ModelStream.js";

package/dist/core/index.js

@@ -1,18 +1,18 @@
 // `zerodrift` — the curated, stable adopter surface. The engine's runtime
 // machinery lives behind `zerodrift/internal` (see internal.ts).
 // ── Enums & serializers ────────────────────────────────────────────────────
-export { LoadStrategy, PropertyType, BootstrapPhase, TransactionState, } from "./types";
-export { dateSerializer, dateDeserializer } from "./serializers";
+export { LoadStrategy, PropertyType, BootstrapPhase, TransactionState, } from "./types.js";
+export { dateSerializer, dateDeserializer } from "./serializers.js";
 // ── Model definition ───────────────────────────────────────────────────────
-export { ClientModel, Property, EphemeralProperty, Reference, LazyReference, ReferenceCollection, LazyReferenceCollection, OwnedCollection, LazyOwnedCollection, BackReference, ReferenceArray, Action, Computed, } from "./decorators";
-export { BaseModel } from "./BaseModel";
+export { ClientModel, Property, EphemeralProperty, Reference, LazyReference, ReferenceCollection, LazyReferenceCollection, OwnedCollection, LazyOwnedCollection, BackReference, ReferenceArray, Action, Computed, } from "./decorators.js";
+export { BaseModel } from "./BaseModel.js";
 // Relation field types — adopters annotate model fields with these
 // (`public issues: RefCollection<Issue>`), so they stay on the curated
 // surface even though their construction is engine-internal.
-export { RefCollection, BackRef, CollectionState } from "./LazyCollection";
-export { OwnedRefs } from "./LazyOwnedCollection";
+export { RefCollection, BackRef, CollectionState } from "./LazyCollection.js";
+export { OwnedRefs } from "./LazyOwnedCollection.js";
 // ── Storage ────────────────────────────────────────────────────────────────
-export { MemoryAdapter } from "./MemoryAdapter";
-export { BootstrapType } from "./Database";
+export { MemoryAdapter } from "./MemoryAdapter.js";
+export { BootstrapType } from "./Database.js";
 // ── Engine ─────────────────────────────────────────────────────────────────
-export { StoreManager, RestrictDeleteError } from "./StoreManager";
+export { StoreManager, RestrictDeleteError } from "./StoreManager.js";

package/dist/core/internal.d.ts

@@ -12,16 +12,16 @@
  * bump. If you find yourself importing from here in app code, that's usually
  * a sign the curated surface is missing something — open an issue.
  */
-export { ObjectPool } from "./ObjectPool";
-export { Database } from "./Database";
-export { ModelRegistry } from "./ModelRegistry";
-export { defineObservableProperty } from "./observability";
-export { FullStore, PartialStore, ModelStore } from "./Store";
-export { BaseTransaction, UpdateTransaction, CreateTransaction, DeleteTransaction, ArchiveTransaction, } from "./Transaction";
-export { TransactionQueue } from "./TransactionQueue";
-export { SyncConnection } from "./SyncConnection";
-export { ModelStream } from "./ModelStream";
-export { normalizeConfig } from "./StoreManager";
-export type { NormalizedConfig } from "./StoreManager";
-export type { IObjectPool, IStoreManager, CoveringPath, } from "./types";
-export { DEFAULT_TRANSIENT_INDEX_DEPTH, toError } from "./types";
+export { ObjectPool } from "./ObjectPool.js";
+export { Database } from "./Database.js";
+export { ModelRegistry } from "./ModelRegistry.js";
+export { defineObservableProperty } from "./observability.js";
+export { FullStore, PartialStore, ModelStore } from "./Store.js";
+export { BaseTransaction, UpdateTransaction, CreateTransaction, DeleteTransaction, ArchiveTransaction, } from "./Transaction.js";
+export { TransactionQueue } from "./TransactionQueue.js";
+export { SyncConnection } from "./SyncConnection.js";
+export { ModelStream } from "./ModelStream.js";
+export { normalizeConfig } from "./StoreManager.js";
+export type { NormalizedConfig } from "./StoreManager.js";
+export type { IObjectPool, IStoreManager, CoveringPath, } from "./types.js";
+export { DEFAULT_TRANSIENT_INDEX_DEPTH, toError } from "./types.js";

package/dist/core/internal.js

@@ -12,14 +12,14 @@
  * bump. If you find yourself importing from here in app code, that's usually
  * a sign the curated surface is missing something — open an issue.
  */
-export { ObjectPool } from "./ObjectPool";
-export { Database } from "./Database";
-export { ModelRegistry } from "./ModelRegistry";
-export { defineObservableProperty } from "./observability";
-export { FullStore, PartialStore, ModelStore } from "./Store";
-export { BaseTransaction, UpdateTransaction, CreateTransaction, DeleteTransaction, ArchiveTransaction, } from "./Transaction";
-export { TransactionQueue } from "./TransactionQueue";
-export { SyncConnection } from "./SyncConnection";
-export { ModelStream } from "./ModelStream";
-export { normalizeConfig } from "./StoreManager";
-export { DEFAULT_TRANSIENT_INDEX_DEPTH, toError } from "./types";
+export { ObjectPool } from "./ObjectPool.js";
+export { Database } from "./Database.js";
+export { ModelRegistry } from "./ModelRegistry.js";
+export { defineObservableProperty } from "./observability.js";
+export { FullStore, PartialStore, ModelStore } from "./Store.js";
+export { BaseTransaction, UpdateTransaction, CreateTransaction, DeleteTransaction, ArchiveTransaction, } from "./Transaction.js";
+export { TransactionQueue } from "./TransactionQueue.js";
+export { SyncConnection } from "./SyncConnection.js";
+export { ModelStream } from "./ModelStream.js";
+export { normalizeConfig } from "./StoreManager.js";
+export { DEFAULT_TRANSIENT_INDEX_DEPTH, toError } from "./types.js";

package/dist/core/observability.js

@@ -19,7 +19,7 @@
  * the raw stored value (for pre-bootstrap access before observability is on).
  */
 import { observable } from "mobx";
-import { BaseModel } from "./BaseModel";
+import { BaseModel } from "./BaseModel.js";
 export function defineObservableProperty(target, propName) {
     // Raw storage key — holds the value before the MobX box is created
     const rawKey = `__raw_${propName}`;

package/dist/core/refAccessors.d.ts

@@ -1,5 +1,5 @@
-import type { IObjectPool } from "./types";
-import type { LazyCollectionBase, BackRef } from "./LazyCollection";
+import type { IObjectPool } from "./types.js";
+import type { LazyCollectionBase, BackRef } from "./LazyCollection.js";
 export interface RefHolder {
     store: IObjectPool | null;
     [key: string]: unknown;

package/dist/core/types.d.ts

@@ -1,4 +1,4 @@
-import type { BaseModel } from "./BaseModel";
+import type { BaseModel } from "./BaseModel.js";
 /** How a model is loaded into the client. Choose by *when* you need its rows. */
 export declare enum LoadStrategy {
     /** Loaded during bootstrap, fully resident, kept current by SSE. The

package/dist/react/index.d.ts

@@ -7,10 +7,10 @@
  * `useRecordsByIndex` (or a relation via `useRelation`).
  */
 import React from "react";
-import { StoreManager, type StoreManagerConfig } from "../core/StoreManager";
-import { BootstrapPhase } from "../core/types";
-import { LazyCollectionBase, BackRef } from "../core/LazyCollection";
-import type { BaseModel } from "../core/BaseModel";
+import { StoreManager, type StoreManagerConfig } from "../core/StoreManager.js";
+import { BootstrapPhase } from "../core/types.js";
+import { LazyCollectionBase, BackRef } from "../core/LazyCollection.js";
+import type { BaseModel } from "../core/BaseModel.js";
 export interface SyncStatus {
     phase: BootstrapPhase;
     detail?: string;
@@ -49,17 +49,17 @@ export interface AsyncResource<T> {
  * the async overload a `Promise<string>`. */
 export declare function useBatch(): StoreManager["batch"];
 export declare function useUndoRedo(): {
-    undo: () => Promise<import("../core").UndoResult | null>;
-    redo: () => Promise<import("../core").UndoResult | null>;
+    undo: () => Promise<import("../core/TransactionQueue.js").UndoResult | null>;
+    redo: () => Promise<import("../core/TransactionQueue.js").UndoResult | null>;
     canUndo: boolean;
     canRedo: boolean;
 };
 export declare function useRelation<T extends BaseModel = BaseModel>(relation: LazyCollectionBase<T> | null | undefined): AsyncResource<T[]>;
 export declare function useRelation<T extends BaseModel = BaseModel>(relation: BackRef<T> | null | undefined): AsyncResource<T | null>;
-import { type EntityNamespace, type RecordWithExtensions } from "../schema/createStore";
-import type { ExtensionDescriptor } from "../schema/extend";
-import type { EntityKey, IndexedFieldKeys } from "../schema/infer";
-import type { SchemaDef } from "../schema/types";
+import { type EntityNamespace, type RecordWithExtensions } from "../schema/createStore.js";
+import type { ExtensionDescriptor } from "../schema/extend.js";
+import type { EntityKey, IndexedFieldKeys } from "../schema/infer.js";
+import type { SchemaDef } from "../schema/types.js";
 type AnyNamespace = EntityNamespace<any, any, any>;
 type ModelCtor<T extends BaseModel = BaseModel> = abstract new (...args: any[]) => T;
 type Handle = AnyNamespace | ModelCtor;

package/dist/react/index.js

@@ -8,10 +8,10 @@ import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
  * `useRecordsByIndex` (or a relation via `useRelation`).
  */
 import { createContext, useContext, useState, useEffect, useCallback, useMemo, useRef, useSyncExternalStore, useLayoutEffect, } from "react";
-import { StoreManager } from "../core/StoreManager";
-import { BootstrapPhase } from "../core/types";
-import { BackRef } from "../core/LazyCollection";
-import { readFk } from "../core/ObjectPool";
+import { StoreManager } from "../core/StoreManager.js";
+import { BootstrapPhase } from "../core/types.js";
+import { BackRef } from "../core/LazyCollection.js";
+import { readFk } from "../core/ObjectPool.js";
 // `<any>` keeps the hooks free of TContext — none of them touch it.
 const SyncContext = createContext(null);
 // ---------------------------------------------------------------------------
@@ -344,7 +344,7 @@ function useStableCallback(callback) {
 // For namespace handles the index key is constrained to the schema's
 // `.indexed()` fields; for class handles it's `string`.
 // ---------------------------------------------------------------------------
-import { entityNamespaceRegistryName, } from "../schema/createStore";
+import { entityNamespaceRegistryName, } from "../schema/createStore.js";
 function handleRegistryName(handle) {
     if (typeof handle === "function") {
         // Set by @ClientModel (explicit { name } or ctor.name fallback).

package/dist/schema/builders.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFieldBuilder, AnyLinkDef, EntityDef, FieldBuilder, FieldMeta, LinkDef, SchemaDef } from "./types";
+import type { AnyFieldBuilder, AnyLinkDef, EntityDef, FieldBuilder, FieldMeta, LinkDef, SchemaDef } from "./types.js";
 export declare function rebuildFieldBuilder<T, M extends FieldMeta>(meta: M): FieldBuilder<T, M>;
 export declare const fields: {
     id: () => FieldBuilder<string, FieldMeta & {

package/dist/schema/builders.js

@@ -1,4 +1,4 @@
-import { dateDeserializer, dateSerializer } from "../core/serializers";
+import { dateDeserializer, dateSerializer } from "../core/serializers.js";
 function makeBuilder(meta) {
     return {
         meta,

package/dist/schema/compile.d.ts

@@ -1,4 +1,4 @@
-import type { SchemaDef } from "./types";
+import type { SchemaDef } from "./types.js";
 export interface CompiledSchema {
     /** Registry names of every entity that was compiled. */
     modelNames: readonly string[];

package/dist/schema/compile.js

@@ -1,9 +1,9 @@
-import { BaseModel } from "../core/BaseModel";
-import { hashString } from "../core/hash";
-import { ModelRegistry } from "../core/ModelRegistry";
-import { defineObservableProperty } from "../core/observability";
-import { installCollectionAccessor, installReferenceAccessor, } from "../core/refAccessors";
-import { PropertyType } from "../core/types";
+import { BaseModel } from "../core/BaseModel.js";
+import { hashString } from "../core/hash.js";
+import { ModelRegistry } from "../core/ModelRegistry.js";
+import { defineObservableProperty } from "../core/observability.js";
+import { installCollectionAccessor, installReferenceAccessor, } from "../core/refAccessors.js";
+import { PropertyType } from "../core/types.js";
 /**
  * Compile a `SchemaDef` produced by `defineSchema(...)` into the existing
  * `ModelRegistry`. Each schema entity becomes a synthetic `BaseModel`

package/dist/schema/createStore.d.ts

@@ -1,8 +1,8 @@
-import type { StoreManager } from "../core/StoreManager";
-import type { UndoResult } from "../core/TransactionQueue";
-import type { ExtensionDescriptor, MergedExtensionMembers } from "./extend";
-import type { EntityKey, IndexedFieldKeys, InferCreateInput, InferEntity, InferUpdateInput } from "./infer";
-import type { SchemaDef } from "./types";
+import type { StoreManager } from "../core/StoreManager.js";
+import type { UndoResult } from "../core/TransactionQueue.js";
+import type { ExtensionDescriptor, MergedExtensionMembers } from "./extend.js";
+import type { EntityKey, IndexedFieldKeys, InferCreateInput, InferEntity, InferUpdateInput } from "./infer.js";
+import type { SchemaDef } from "./types.js";
 /**
  * Curated subset of `BaseModel` lifecycle methods we expose on records so
  * imperative "mutate fields then commit" workflows have a typed path. Keeps

package/dist/schema/createStore.js

@@ -1,8 +1,8 @@
 import { action, computed } from "mobx";
-import { ModelRegistry } from "../core/ModelRegistry";
-import { prop } from "../core/ObjectPool";
-import { installActionMethod, installComputedAccessor, } from "../core/refAccessors";
-import { compileSchema } from "./compile";
+import { ModelRegistry } from "../core/ModelRegistry.js";
+import { prop } from "../core/ObjectPool.js";
+import { installActionMethod, installComputedAccessor, } from "../core/refAccessors.js";
+import { compileSchema } from "./compile.js";
 /**
  * Project a `SchemaDef` over a live `StoreManager`. The runtime values are
  * `BaseModel` instances that structurally satisfy the inferred record type;

package/dist/schema/extend.d.ts

@@ -1,5 +1,5 @@
-import type { EntityKey, InferEntity } from "./infer";
-import type { SchemaDef } from "./types";
+import type { EntityKey, InferEntity } from "./infer.js";
+import type { SchemaDef } from "./types.js";
 export type ComputedFn<S extends SchemaDef, K extends EntityKey<S>> = (record: InferEntity<S, K>) => unknown;
 export type ActionFn<S extends SchemaDef, K extends EntityKey<S>> = (record: InferEntity<S, K>, ...args: never[]) => unknown;
 export interface ExtensionDef<S extends SchemaDef, K extends EntityKey<S>> {

package/dist/schema/index.d.ts

@@ -1,13 +1,13 @@
-export { LoadStrategy } from "../core/types";
-export { defineSchema, entity, link, fields } from "./builders";
-export { fields as s } from "./builders";
-export { compileSchema } from "./compile";
-export type { CompiledSchema } from "./compile";
-export { createStore } from "./createStore";
-export type { EntityStore, EntityNamespace, RecordWithExtensions, StoreApi, } from "./createStore";
-export { extend } from "./extend";
-export type { ActionFn, ComputedFn, ExtensionDef, ExtensionDescriptor, ExtensionMap, MergedExtensionMembers, } from "./extend";
-export { fromZod, entityFromZod } from "./zod";
-export type { EntityFromZodFieldOverride, EntityFromZodOpts } from "./zod";
-export type { EntityDef, FieldBuilder, FieldKind, FieldMeta, LinkDef, LinkFromSpec, LinkToSpec, OnDelete, SchemaDef, } from "./types";
-export type { EntityKey, IndexedFieldKeys, InferCreateInput, InferEntity, InferUpdateInput, RelationCollection, } from "./infer";
+export { LoadStrategy } from "../core/types.js";
+export { defineSchema, entity, link, fields } from "./builders.js";
+export { fields as s } from "./builders.js";
+export { compileSchema } from "./compile.js";
+export type { CompiledSchema } from "./compile.js";
+export { createStore } from "./createStore.js";
+export type { EntityStore, EntityNamespace, RecordWithExtensions, StoreApi, } from "./createStore.js";
+export { extend } from "./extend.js";
+export type { ActionFn, ComputedFn, ExtensionDef, ExtensionDescriptor, ExtensionMap, MergedExtensionMembers, } from "./extend.js";
+export { fromZod, entityFromZod } from "./zod.js";
+export type { EntityFromZodFieldOverride, EntityFromZodOpts } from "./zod.js";
+export type { EntityDef, FieldBuilder, FieldKind, FieldMeta, LinkDef, LinkFromSpec, LinkToSpec, OnDelete, SchemaDef, } from "./types.js";
+export type { EntityKey, IndexedFieldKeys, InferCreateInput, InferEntity, InferUpdateInput, RelationCollection, } from "./infer.js";

package/dist/schema/index.js

@@ -1,8 +1,8 @@
 // Public schema-authoring surface. See agent-docs/RFC-schema-first-authoring.md.
-export { LoadStrategy } from "../core/types";
-export { defineSchema, entity, link, fields } from "./builders";
-export { fields as s } from "./builders";
-export { compileSchema } from "./compile";
-export { createStore } from "./createStore";
-export { extend } from "./extend";
-export { fromZod, entityFromZod } from "./zod";
+export { LoadStrategy } from "../core/types.js";
+export { defineSchema, entity, link, fields } from "./builders.js";
+export { fields as s } from "./builders.js";
+export { compileSchema } from "./compile.js";
+export { createStore } from "./createStore.js";
+export { extend } from "./extend.js";
+export { fromZod, entityFromZod } from "./zod.js";

package/dist/schema/infer.d.ts

@@ -1,4 +1,4 @@
-import type { EntityDef, FieldBuilder, FieldMeta, SchemaDef } from "./types";
+import type { EntityDef, FieldBuilder, FieldMeta, SchemaDef } from "./types.js";
 type FieldType<F> = F extends FieldBuilder<infer T, FieldMeta> ? T : never;
 type FieldIsNullable<F> = null extends FieldType<F> ? true : false;
 type FieldIsIndexed<F> = F extends FieldBuilder<unknown, infer M> ? M extends {

package/dist/schema/types.d.ts

@@ -1,4 +1,4 @@
-import type { LoadStrategy, OnDelete } from "../core/types";
+import type { LoadStrategy, OnDelete } from "../core/types.js";
 export type FieldKind = "id" | "string" | "number" | "boolean" | "date" | "json" | "refId";
 export interface FieldMeta {
     kind: FieldKind;

package/dist/schema/zod.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import type { AnyFieldBuilder, EntityDef, FieldBuilder } from "./types";
+import type { AnyFieldBuilder, EntityDef, FieldBuilder } from "./types.js";
 /**
  * Convert any Zod schema into the equivalent schema-first `FieldBuilder`.
  * Handles the common nullable / optional / default modifiers; anything more

package/dist/schema/zod.js

@@ -1,4 +1,4 @@
-import { fields, entity, rebuildFieldBuilder } from "./builders";
+import { fields, entity, rebuildFieldBuilder } from "./builders.js";
 const PRIMITIVE_KIND = new Map([
     ["string", fields.string],
     ["number", fields.number],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zerodrift",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "private": false,
   "description": "A TypeScript local-first sync engine: synchronous in-memory reads, optimistic writes, realtime SSE sync, offline IndexedDB persistence. Runs in the browser and in Node.",
   "license": "MIT",