zerodrift 1.0.3 → 1.0.4

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.3",
+  "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",