zerodrift 1.0.0

package/dist/core/decorators.js

@@ -0,0 +1,278 @@
+/**
+ * Decorators for defining models and their properties.
+ *
+ * Usage looks like:
+ *
+ *   @ClientModel({ loadStrategy: LoadStrategy.Eager })
+ *   class Issue extends BaseModel {
+ *     @Property() title = "";
+ *     @Reference("User", { nullable: true }) assignee: any;
+ *     @Action moveToTeam(id: string) { ... }
+ *     @Computed get identifier() { ... }
+ *   }
+ *
+ * Each decorator registers metadata in the ModelRegistry at class-definition
+ * 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";
+const pendingByClass = new WeakMap();
+function getOrCreatePending(ctor) {
+    let entry = pendingByClass.get(ctor);
+    if (entry == null) {
+        entry = {
+            properties: new Map(),
+            actions: new Set(),
+            computedProps: new Set(),
+        };
+        pendingByClass.set(ctor, entry);
+    }
+    return entry;
+}
+function stashProperty(ctor, prop) {
+    getOrCreatePending(ctor).properties.set(prop.name, prop);
+}
+function updateStashedProperty(ctor, name, updates) {
+    const pending = getOrCreatePending(ctor);
+    const existing = pending.properties.get(name);
+    if (existing == null) {
+        throw new Error(`Property "${name}" not found on model "${ctor.name}". ` +
+            `Declare it with @Property() before applying @Reference.`);
+    }
+    pending.properties.set(name, { ...existing, ...updates });
+}
+function stashAction(ctor, name) {
+    getOrCreatePending(ctor).actions.add(name);
+}
+function stashComputed(ctor, name) {
+    getOrCreatePending(ctor).computedProps.add(name);
+}
+/** Walk the prototype chain from `ctor`, draining each class's pending
+ * metadata into `meta`. Pending entries are NOT deleted on drain so multiple
+ * subclasses sharing an abstract base each inherit independently, AND deeper
+ * chains (`A extends B extends M`, where B is itself a live model) keep
+ * working — when @ClientModel runs on A it re-walks pending(B) which still
+ * holds B's declarations.
+ *
+ * Subclass-declared properties win over ancestor-declared ones with the same
+ * name (`Map.set` is no-op-when-present via the `has` guard).
+ */
+function drainPendingChain(ctor, meta) {
+    // Walk the *constructor* chain (not the prototype chain): for
+    // `class B extends A`, `Object.getPrototypeOf(B)` returns `A`, and the
+    // chain terminates at `Function.prototype`. Stopping there is sufficient;
+    // no model class extends `Object` directly.
+    let current = ctor;
+    while (current != null && current !== Function.prototype) {
+        const pending = pendingByClass.get(current);
+        if (pending != null) {
+            for (const [name, prop] of pending.properties) {
+                if (!meta.properties.has(name)) {
+                    meta.properties.set(name, prop);
+                }
+            }
+            for (const action of pending.actions) {
+                meta.actions.add(action);
+            }
+            for (const computed of pending.computedProps) {
+                meta.computedProps.add(computed);
+            }
+        }
+        current = Object.getPrototypeOf(current);
+    }
+}
+/** Models registered without an explicit `name`, for the one-shot dev warning. */
+const ctorNameFallbacks = new Set();
+export function ClientModel(opts = {}) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (ctor) {
+        const modelName = opts.name ?? ctor.name;
+        if (opts.name == null &&
+            typeof process !== "undefined" &&
+            process.env?.NODE_ENV !== "production" &&
+            !ctorNameFallbacks.has(modelName)) {
+            ctorNameFallbacks.add(modelName);
+            console.warn(`[zerodrift] @ClientModel on "${modelName}" has no explicit ` +
+                `{ name } and is keyed on ctor.name. Minified production builds ` +
+                `mangle class names — pass @ClientModel({ name: "${modelName}" }) ` +
+                `or set your bundler's keep_classnames.`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ctor._modelName = modelName;
+        const meta = ModelRegistry.registerModel(modelName, ctor);
+        if (opts.loadStrategy != null) {
+            meta.loadStrategy = opts.loadStrategy;
+        }
+        if (opts.usedForPartialIndexes != null) {
+            meta.usedForPartialIndexes = opts.usedForPartialIndexes;
+        }
+        if (opts.schemaVersion != null) {
+            meta.schemaVersion = opts.schemaVersion;
+        }
+        // Drain decorator-stashed metadata for this class and every ancestor up
+        // the prototype chain. Abstract bases never registered themselves; their
+        // pending entries are read-only from this point on (so siblings sharing
+        // a base each inherit independently).
+        drainPendingChain(ctor, meta);
+        return ctor;
+    };
+}
+// ---------------------------------------------------------------------------
+// @Property — persisted, observable property
+// ---------------------------------------------------------------------------
+export function Property(opts = {}) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.Property,
+            indexed: opts.indexed,
+            serializer: opts.serializer,
+            deserializer: opts.deserializer,
+        });
+        defineObservableProperty(target, key);
+    };
+}
+// ---------------------------------------------------------------------------
+// @EphemeralProperty — observable but NOT persisted to IndexedDB
+// ---------------------------------------------------------------------------
+export function EphemeralProperty() {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.EphemeralProperty,
+        });
+        defineObservableProperty(target, key);
+    };
+}
+function defineReference(lazy, referenceTo, opts) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        const idKey = opts.idField ?? key + "Id";
+        updateStashedProperty(target.constructor, idKey, {
+            type: PropertyType.Reference,
+            referenceTo,
+            nullable: opts.nullable,
+            onDelete: opts.onDelete,
+            lazy,
+        });
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.ReferenceModel,
+            referenceTo,
+            idField: idKey,
+        });
+        installReferenceAccessor(target, key, idKey, referenceTo);
+    };
+}
+export function Reference(referenceTo, opts = {}) {
+    return defineReference(false, referenceTo, opts);
+}
+export function LazyReference(referenceTo, opts = {}) {
+    return defineReference(true, referenceTo, opts);
+}
+function defineReferenceCollection(lazy, referenceTo, opts) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        const modelName = target.constructor.name;
+        // Derive the foreign key on the child model. Convention: parentModelName
+        // (lowercased first char) + "Id". Override with inverseOf when needed.
+        const inverseKey = opts.inverseOf ??
+            modelName.charAt(0).toLowerCase() + modelName.slice(1) + "Id";
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.ReferenceCollection,
+            referenceTo,
+            lazy,
+            inverseOf: inverseKey,
+            coveringIndexes: opts.coveringIndexes,
+        });
+        installCollectionAccessor(target, key);
+    };
+}
+export function ReferenceCollection(referenceTo, opts = {}) {
+    return defineReferenceCollection(false, referenceTo, opts);
+}
+export function LazyReferenceCollection(referenceTo, opts = {}) {
+    return defineReferenceCollection(true, referenceTo, opts);
+}
+// ---------------------------------------------------------------------------
+// @BackReference — inverse of a Reference
+//
+// Metadata-only registration. The runtime BackRef is created in
+// BaseModel.makeModelObservable().
+//
+// Key behavior: a BackReference is "owned" by the referenced model.
+// When the owning model is deleted, the back-referenced model is also removed.
+// This cascade is handled in SyncConnection during delta packet processing.
+// ---------------------------------------------------------------------------
+export function BackReference(referenceTo, inverseOf) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.BackReference,
+            referenceTo,
+            inverseOf,
+        });
+        installBackRefAccessor(target, key);
+    };
+}
+// ---------------------------------------------------------------------------
+// @ReferenceArray — many-to-many stored as array of IDs
+// ---------------------------------------------------------------------------
+export function ReferenceArray(referenceTo) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.ReferenceArray,
+            referenceTo,
+        });
+        defineObservableProperty(target, key);
+    };
+}
+function defineOwnedCollection(lazy, referenceTo, opts) {
+    // Legacy decorator target — no better type exists for prototype manipulation
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (target, key) {
+        stashProperty(target.constructor, {
+            name: key,
+            type: PropertyType.OwnedCollection,
+            referenceTo,
+            idsField: opts.idsField,
+            lazy,
+        });
+        installCollectionAccessor(target, key);
+    };
+}
+export function OwnedCollection(referenceTo, opts) {
+    return defineOwnedCollection(false, referenceTo, opts);
+}
+export function LazyOwnedCollection(referenceTo, opts) {
+    return defineOwnedCollection(true, referenceTo, opts);
+}
+// ---------------------------------------------------------------------------
+// @Action and @Computed — register method names for MobX wiring
+// ---------------------------------------------------------------------------
+// Legacy decorator target — no better type exists for prototype manipulation
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Action(target, key, _d) {
+    stashAction(target.constructor, key);
+}
+// Legacy decorator target — no better type exists for prototype manipulation
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Computed(target, key, _d) {
+    stashComputed(target.constructor, key);
+}

package/dist/core/hash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Stable string-to-int hash (djb2-style). Used by `ModelRegistry.schemaHash`
+ * and the schema compiler's per-entity `schemaVersion`. Not cryptographic —
+ * just deterministic across runs and cheap. Returns a non-negative integer.
+ */
+export declare function hashString(input: string): number;

package/dist/core/hash.js

@@ -0,0 +1,12 @@
+/**
+ * Stable string-to-int hash (djb2-style). Used by `ModelRegistry.schemaHash`
+ * and the schema compiler's per-entity `schemaVersion`. Not cryptographic —
+ * just deterministic across runs and cheap. Returns a non-negative integer.
+ */
+export function hashString(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash);
+}

package/dist/core/index.d.ts

@@ -0,0 +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";

package/dist/core/index.js

@@ -0,0 +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";
+// ── Model definition ───────────────────────────────────────────────────────
+export { ClientModel, Property, EphemeralProperty, Reference, LazyReference, ReferenceCollection, LazyReferenceCollection, OwnedCollection, LazyOwnedCollection, BackReference, ReferenceArray, Action, Computed, } from "./decorators";
+export { BaseModel } from "./BaseModel";
+// 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";
+// ── Storage ────────────────────────────────────────────────────────────────
+export { MemoryAdapter } from "./MemoryAdapter";
+export { BootstrapType } from "./Database";
+// ── Engine ─────────────────────────────────────────────────────────────────
+export { StoreManager, RestrictDeleteError } from "./StoreManager";

package/dist/core/internal.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `zerodrift/internal` — engine internals with NO stability promise.
+ *
+ * These are the runtime machinery the curated `zerodrift` entry point
+ * deliberately hides: the pool, storage, transaction queue/objects, the SSE
+ * connection/stream, the per-strategy stores, the model registry, and the
+ * config normalizer. They are exported only for tooling, tests, and the rare
+ * adopter that genuinely needs to reach under the engine (e.g. a devtool
+ * walking `ModelRegistry`, or a test driving `ObjectPool` directly).
+ *
+ * Anything here may change shape or vanish between releases without a major
+ * 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";

package/dist/core/internal.js

@@ -0,0 +1,25 @@
+/**
+ * `zerodrift/internal` — engine internals with NO stability promise.
+ *
+ * These are the runtime machinery the curated `zerodrift` entry point
+ * deliberately hides: the pool, storage, transaction queue/objects, the SSE
+ * connection/stream, the per-strategy stores, the model registry, and the
+ * config normalizer. They are exported only for tooling, tests, and the rare
+ * adopter that genuinely needs to reach under the engine (e.g. a devtool
+ * walking `ModelRegistry`, or a test driving `ObjectPool` directly).
+ *
+ * Anything here may change shape or vanish between releases without a major
+ * 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";

package/dist/core/observability.d.ts

@@ -0,0 +1,21 @@
+/**
+ * defineObservableProperty
+ *
+ * Replaces a class property with a getter/setter pair using Object.defineProperty.
+ *
+ * The setter does three things:
+ *   1. Lazily creates a MobX observable box on `this.__mobx[propName]`
+ *   2. Stores the value in the box (so MobX can track reads/writes)
+ *   3. Calls `this.propertyChanged(name, oldValue, newValue)` to feed
+ *      the change-tracking system that generates transactions
+ *
+ * Before any of that, if a wired `StoreManager` has registered field
+ * transforms via `applyFieldTransforms`, the assigned value is routed
+ * through `sm.applyTransform` so consumers can canonicalize input on the
+ * way in. The `hasFieldTransforms` short-circuit keeps the no-config
+ * setter path a single boolean read.
+ *
+ * The getter reads from the MobX box if it exists, otherwise returns
+ * the raw stored value (for pre-bootstrap access before observability is on).
+ */
+export declare function defineObservableProperty(target: object, propName: string): void;

package/dist/core/observability.js

@@ -0,0 +1,66 @@
+/**
+ * defineObservableProperty
+ *
+ * Replaces a class property with a getter/setter pair using Object.defineProperty.
+ *
+ * The setter does three things:
+ *   1. Lazily creates a MobX observable box on `this.__mobx[propName]`
+ *   2. Stores the value in the box (so MobX can track reads/writes)
+ *   3. Calls `this.propertyChanged(name, oldValue, newValue)` to feed
+ *      the change-tracking system that generates transactions
+ *
+ * Before any of that, if a wired `StoreManager` has registered field
+ * transforms via `applyFieldTransforms`, the assigned value is routed
+ * through `sm.applyTransform` so consumers can canonicalize input on the
+ * way in. The `hasFieldTransforms` short-circuit keeps the no-config
+ * setter path a single boolean read.
+ *
+ * The getter reads from the MobX box if it exists, otherwise returns
+ * the raw stored value (for pre-bootstrap access before observability is on).
+ */
+import { observable } from "mobx";
+import { BaseModel } from "./BaseModel";
+export function defineObservableProperty(target, propName) {
+    // Raw storage key — holds the value before the MobX box is created
+    const rawKey = `__raw_${propName}`;
+    Object.defineProperty(target, propName, {
+        configurable: true,
+        enumerable: true,
+        // Legacy decorator target — no better type exists for prototype manipulation
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        get() {
+            // If observability is active, read from the MobX box (tracked read)
+            if (this.__mobx?.[propName]) {
+                return this.__mobx[propName].get();
+            }
+            // Otherwise return the raw value (pre-bootstrap)
+            return this[rawKey];
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        set(newValue) {
+            const sm = BaseModel.storeManager;
+            if (sm != null && sm.hasFieldTransforms) {
+                newValue = sm.applyTransform(this, propName, newValue);
+            }
+            const oldValue = this[propName]; // read via getter above
+            // Create the __mobx container if it doesn't exist yet
+            if (!this.__mobx) {
+                this.__mobx = {};
+            }
+            // Create or update the MobX observable box
+            if (!this.__mobx[propName]) {
+                this.__mobx[propName] = observable.box(newValue, { deep: false });
+            }
+            else {
+                this.__mobx[propName].set(newValue);
+            }
+            // Also store raw value for pre-observable access
+            this[rawKey] = newValue;
+            // Notify the change-tracking system (only after makeModelObservable())
+            if (this.__observabilityEnabled &&
+                typeof this.propertyChanged === "function") {
+                this.propertyChanged(propName, oldValue, newValue);
+            }
+        },
+    });
+}

package/dist/core/refAccessors.d.ts

@@ -0,0 +1,43 @@
+import type { IObjectPool } from "./types";
+import type { LazyCollectionBase, BackRef } from "./LazyCollection";
+export interface RefHolder {
+    store: IObjectPool | null;
+    [key: string]: unknown;
+}
+export interface CollectionHolder {
+    __collections?: Record<string, LazyCollectionBase>;
+}
+export interface BackRefHolder {
+    __backRefs?: Record<string, BackRef>;
+}
+/**
+ * Install the prototype getter/setter pair that powers a singular relation.
+ * The getter resolves the FK via the pool and tracks the entry so observers
+ * re-run on identity swaps; the setter writes the FK from the model's id.
+ *
+ * Used by `@Reference` / `@LazyReference` decorators and by the schema-first
+ * compiler so the runtime accessor shape is identical across both authoring
+ * paths.
+ */
+export declare function installReferenceAccessor(prototype: object, key: string, idField: string, referenceTo: string): void;
+/**
+ * Install the prototype getter that exposes the runtime `LazyCollectionBase`
+ * stored on `this.__collections[key]`. The collection itself is created
+ * during `BaseModel.makeModelObservable()`.
+ */
+export declare function installCollectionAccessor(prototype: object, key: string): void;
+/** Install the prototype getter for a `BackRef` runtime collection. */
+export declare function installBackRefAccessor(prototype: object, key: string): void;
+/**
+ * Install a prototype getter that calls `fn(this)` whenever the property is
+ * read. `BaseModel.makeModelObservable()` later replaces the per-instance
+ * binding with a MobX `computed`, so reads are memoized once observability
+ * is enabled. Used by the schema-first `extend(...)` pipeline.
+ */
+export declare function installComputedAccessor(prototype: object, key: string, fn: (record: object) => unknown): void;
+/**
+ * Install a prototype method that calls `fn(this, ...args)`.
+ * `BaseModel.makeModelObservable()` later wraps the per-instance binding
+ * with MobX `action` for write batching.
+ */
+export declare function installActionMethod(prototype: object, key: string, fn: (record: object, ...args: never[]) => unknown): void;

package/dist/core/refAccessors.js

@@ -0,0 +1,80 @@
+/**
+ * Install the prototype getter/setter pair that powers a singular relation.
+ * The getter resolves the FK via the pool and tracks the entry so observers
+ * re-run on identity swaps; the setter writes the FK from the model's id.
+ *
+ * Used by `@Reference` / `@LazyReference` decorators and by the schema-first
+ * compiler so the runtime accessor shape is identical across both authoring
+ * paths.
+ */
+export function installReferenceAccessor(prototype, key, idField, referenceTo) {
+    Object.defineProperty(prototype, key, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            const id = this[idField];
+            if (typeof id !== "string" || id === "") {
+                return null;
+            }
+            this.store?.trackModel(referenceTo, id);
+            return this.store?.getById(referenceTo, id) ?? null;
+        },
+        set(model) {
+            this[idField] = model != null ? model.id : null;
+        },
+    });
+}
+/**
+ * Install the prototype getter that exposes the runtime `LazyCollectionBase`
+ * stored on `this.__collections[key]`. The collection itself is created
+ * during `BaseModel.makeModelObservable()`.
+ */
+export function installCollectionAccessor(prototype, key) {
+    Object.defineProperty(prototype, key, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return this.__collections?.[key] ?? null;
+        },
+    });
+}
+/** Install the prototype getter for a `BackRef` runtime collection. */
+export function installBackRefAccessor(prototype, key) {
+    Object.defineProperty(prototype, key, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return this.__backRefs?.[key] ?? null;
+        },
+    });
+}
+/**
+ * Install a prototype getter that calls `fn(this)` whenever the property is
+ * read. `BaseModel.makeModelObservable()` later replaces the per-instance
+ * binding with a MobX `computed`, so reads are memoized once observability
+ * is enabled. Used by the schema-first `extend(...)` pipeline.
+ */
+export function installComputedAccessor(prototype, key, fn) {
+    Object.defineProperty(prototype, key, {
+        configurable: true,
+        enumerable: false,
+        get() {
+            return fn(this);
+        },
+    });
+}
+/**
+ * Install a prototype method that calls `fn(this, ...args)`.
+ * `BaseModel.makeModelObservable()` later wraps the per-instance binding
+ * with MobX `action` for write batching.
+ */
+export function installActionMethod(prototype, key, fn) {
+    Object.defineProperty(prototype, key, {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value(...args) {
+            return fn(this, ...args);
+        },
+    });
+}

package/dist/core/serializers.d.ts

@@ -0,0 +1,2 @@
+export declare const dateSerializer: (value: unknown) => unknown;
+export declare const dateDeserializer: (raw: unknown) => unknown;

package/dist/core/serializers.js

@@ -0,0 +1,2 @@
+export const dateSerializer = (value) => value instanceof Date ? value.toISOString() : value;
+export const dateDeserializer = (raw) => typeof raw === "string" ? new Date(raw) : raw;