@justscale/core 0.1.0

package/dist/models/model.repository.js

@@ -0,0 +1,146 @@
+/**
+ * ModelRepository - Abstract Repository with Token System
+ *
+ * Base class for data access that works with the query system.
+ * Implementations (Postgres, SQLite, Memory) extend this.
+ *
+ * Key features:
+ * - ModelRepository<T> is the abstract contract for CRUD operations
+ * - ModelRepository.of(Model) creates a DI token for injection
+ *
+ * @example
+ * ```typescript
+ * // Get a token for dependency injection
+ * const userRepoToken = ModelRepository.of(User);
+ *
+ * // Domain service depends on the token
+ * const UserService = defineService({
+ *   inject: { users: ModelRepository.of(User) },
+ *   factory: ({ users }) => ({
+ *     async findByEmail(email: string) {
+ *       return users.findOne(User.fields.email.eq(email));
+ *     },
+ *   }),
+ * });
+ * ```
+ */
+import { MODEL_STABLE_ID } from './define-model.js';
+import { Repository, REPO_TOKEN } from './repository.js';
+import { MODEL_REPO_MODEL, MODEL_REPO_CONTRACT } from './symbols.js';
+// Re-export for convenience
+export { MODEL_REPO_MODEL, MODEL_REPO_CONTRACT };
+/**
+ * Abstract repository for model data access.
+ *
+ * Extends the generic Repository from core with model-specific operations
+ * like find, get, insert, update, delete, and query support.
+ *
+ * Implementations can be created for PostgreSQL, SQLite, in-memory, etc.
+ *
+ * @typeParam T - The entity type this repository manages
+ */
+export class ModelRepository extends Repository {
+    /**
+     * Check if any entity matches the condition.
+     */
+    async exists(where) {
+        const count = await this.count(where);
+        return count > 0;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+    // Static Token Factory
+    // ─────────────────────────────────────────────────────────────────────────
+    /**
+     * Get a DI token for a model's repository.
+     *
+     * Tokens are memoized - same model always returns same token object.
+     * This enables object identity comparison for DI container lookups.
+     *
+     * If the model has a repository contract (via .withRepository()), the token
+     * type includes those custom methods.
+     *
+     * @example
+     * ```typescript
+     * const token = ModelRepository.of(User);
+     *
+     * // Same model = same token (object identity)
+     * ModelRepository.of(User) === ModelRepository.of(User)  // true
+     *
+     * // Different models = different tokens
+     * ModelRepository.of(User) === ModelRepository.of(Post)  // false
+     *
+     * // With custom contract
+     * const UserWithRepo = User.withRepository<{
+     *   findByEmail(email: string): Promise<User | null>;
+     * }>();
+     * const token = ModelRepository.of(UserWithRepo);
+     * // token type includes findByEmail method
+     * ```
+     */
+    // biome-ignore lint/suspicious/noExplicitAny: Using any to avoid variance issues
+    static of(model) {
+        // biome-ignore lint/suspicious/noExplicitAny: Dynamic token creation
+        return getOrCreateToken(model);
+    }
+}
+// ============================================================================
+// Token Registry (WeakMap for memoization)
+// ============================================================================
+// biome-ignore lint/suspicious/noExplicitAny: Internal registry uses any
+const tokenRegistry = new WeakMap();
+// Secondary index by stable ID - two classes with the same stable ID (e.g. after HMR)
+// resolve to the same token without any special-casing.
+// biome-ignore lint/suspicious/noExplicitAny: dynamic token type
+const tokenRegistryByStableId = new Map();
+function getOrCreateToken(model) {
+    const stableId = model[MODEL_STABLE_ID];
+    if (stableId) {
+        const cached = tokenRegistryByStableId.get(stableId);
+        if (cached) {
+            // Fresh class ref with same stable ID - update token's model
+            // slot so reads see the current class's fields / metadata.
+            if (cached[MODEL_REPO_MODEL] !== model) {
+                Object.defineProperty(cached, MODEL_REPO_MODEL, {
+                    value: model,
+                    enumerable: false,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            return cached;
+        }
+    }
+    let token = tokenRegistry.get(model);
+    if (!token) {
+        const description = `ModelRepository<${model.name}>`;
+        // biome-ignore lint/suspicious/noExplicitAny: Token creation is dynamic
+        token = Object.create(null);
+        Object.defineProperties(token, {
+            [REPO_TOKEN]: { value: true, enumerable: false },
+            [MODEL_REPO_MODEL]: { value: model, enumerable: false, writable: true, configurable: true },
+            description: { value: description, enumerable: true },
+            toString: { value: () => description, enumerable: false },
+        });
+        // Intentionally NOT frozen: `MODEL_REPO_MODEL` must stay writable
+        // so a fresh class ref with the same stable ID can swap its
+        // internal model target without losing token identity.
+        tokenRegistry.set(model, token);
+        if (stableId)
+            tokenRegistryByStableId.set(stableId, token);
+    }
+    else if (stableId && !tokenRegistryByStableId.has(stableId)) {
+        tokenRegistryByStableId.set(stableId, token);
+    }
+    return token;
+}
+/**
+ * Check if a value is a ModelRepository token.
+ */
+export function isModelRepositoryToken(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        REPO_TOKEN in value &&
+        value[REPO_TOKEN] === true &&
+        MODEL_REPO_MODEL in value);
+}
+//# sourceMappingURL=model.repository.js.map

package/dist/models/model.repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.repository.js","sourceRoot":"","sources":["../../src/models/model.repository.ts"],"names":[],"mappings":"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"}

package/dist/models/observable.d.ts

@@ -0,0 +1,15 @@
+import type { Observable, ObservableInternals } from './types.js';
+/**
+ * Create a standalone observable object with dirty tracking.
+ * Can be used independently or passed into models.
+ */
+export declare function createObservable<T extends object>(data: T): Observable<T>;
+/**
+ * Get the internals of an observable
+ */
+export declare function getObservableInternals<T extends object>(observable: Observable<T>): ObservableInternals;
+/**
+ * Check if a value is an observable
+ */
+export declare function isObservable<T extends object>(value: unknown): value is Observable<T>;
+//# sourceMappingURL=observable.d.ts.map

package/dist/models/observable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.d.ts","sourceRoot":"","sources":["../../src/models/observable.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAoBlE;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAkCzE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,MAAM,EACrD,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GACxB,mBAAmB,CAErB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,CAAC,CAErF"}

package/dist/models/observable.js

@@ -0,0 +1,64 @@
+import { createTrackedProxy } from './proxy.js';
+import { OBSERVABLE_META } from './symbols.js';
+// Deep traverse to ensure all nested objects are proxied
+function deepTraverse(obj, visited = new WeakSet()) {
+    if (obj === null || typeof obj !== 'object')
+        return;
+    if (visited.has(obj))
+        return;
+    visited.add(obj);
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            deepTraverse(obj[i], visited);
+        }
+    }
+    else {
+        for (const key of Object.keys(obj)) {
+            deepTraverse(obj[key], visited);
+        }
+    }
+}
+/**
+ * Create a standalone observable object with dirty tracking.
+ * Can be used independently or passed into models.
+ */
+export function createObservable(data) {
+    const dirty = new Set();
+    // Create the root proxy
+    const proxy = createTrackedProxy(data, [], dirty);
+    // Traverse to ensure all nested objects are proxied upfront
+    deepTraverse(proxy);
+    const internals = {
+        dirty,
+        markClean() {
+            dirty.clear();
+        },
+        isDirty() {
+            return dirty.size > 0;
+        },
+        getDirtyPaths() {
+            return [...dirty];
+        },
+    };
+    // Attach internals to the underlying object
+    Object.defineProperty(data, OBSERVABLE_META, {
+        value: internals,
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return proxy;
+}
+/**
+ * Get the internals of an observable
+ */
+export function getObservableInternals(observable) {
+    return observable[OBSERVABLE_META];
+}
+/**
+ * Check if a value is an observable
+ */
+export function isObservable(value) {
+    return value !== null && typeof value === 'object' && OBSERVABLE_META in value;
+}
+//# sourceMappingURL=observable.js.map

package/dist/models/observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/models/observable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAG/C,yDAAyD;AACzD,SAAS,YAAY,CAAC,GAAY,EAAE,UAAU,IAAI,OAAO,EAAU;IACjE,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO;IACpD,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;QAAE,OAAO;IAE7B,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAEjB,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;SAAM,CAAC;QACN,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,YAAY,CAAE,GAA+B,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAmB,IAAO;IACxD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAEhC,wBAAwB;IACxB,MAAM,KAAK,GAAG,kBAAkB,CAAC,IAAI,EAAE,EAAE,EAAE,KAAK,CAAM,CAAC;IAEvD,4DAA4D;IAC5D,YAAY,CAAC,KAAK,CAAC,CAAC;IAEpB,MAAM,SAAS,GAAwB;QACrC,KAAK;QAEL,SAAS;YACP,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;QAED,OAAO;YACL,OAAO,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC;QACxB,CAAC;QAED,aAAa;YACX,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;QACpB,CAAC;KACF,CAAC;IAEF,4CAA4C;IAC5C,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE;QAC3C,KAAK,EAAE,SAAS;QAChB,UAAU,EAAE,KAAK;QACjB,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,KAAK;KACpB,CAAC,CAAC;IAEH,OAAO,KAAsB,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,sBAAsB,CACpC,UAAyB;IAEzB,OAAO,UAAU,CAAC,eAAe,CAAC,CAAC;AACrC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,YAAY,CAAmB,KAAc;IAC3D,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,eAAe,IAAI,KAAK,CAAC;AACjF,CAAC"}

package/dist/models/proxy.d.ts

@@ -0,0 +1,5 @@
+import type { ProxyMeta } from './types.js';
+export declare function createTrackedProxy(target: object, path: string[], dirtySet: Set<string>, parent?: ProxyMeta, keyInParent?: string): object;
+export declare function getProxyMeta(proxy: object): ProxyMeta | undefined;
+export declare function isTrackedProxy(obj: unknown): boolean;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/models/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/models/proxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAoQ5C,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAAE,EACd,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,EACrB,MAAM,CAAC,EAAE,SAAS,EAClB,WAAW,CAAC,EAAE,MAAM,GACnB,MAAM,CA6MR;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAEjE;AAGD,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAEpD"}

package/dist/models/proxy.js

@@ -0,0 +1,407 @@
+import { MODEL_INTERNALS, OBSERVABLE_META } from './symbols.js';
+import { notifyWatchers } from './watch.js';
+// Built-in objects with internal slots that break when methods are called with proxy as `this`
+// These require binding to the original target, not the proxy
+const BUILTIN_WITH_INTERNAL_SLOTS = new Set([
+    Map,
+    Set,
+    WeakMap,
+    WeakSet,
+    Date,
+    ArrayBuffer,
+    SharedArrayBuffer,
+    DataView,
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array,
+    RegExp,
+    Promise,
+]);
+function hasInternalSlots(obj) {
+    for (const BuiltIn of BUILTIN_WITH_INTERNAL_SLOTS) {
+        if (obj instanceof BuiltIn)
+            return true;
+    }
+    return false;
+}
+// Methods that mutate built-in objects - we need to track these
+const MAP_MUTATORS = new Set(['set', 'delete', 'clear']);
+const WEAKMAP_MUTATORS = new Set(['set', 'delete']);
+const SET_MUTATORS = new Set(['add', 'delete', 'clear']);
+const WEAKSET_MUTATORS = new Set(['add', 'delete']);
+const DATE_MUTATORS = new Set([
+    'setDate',
+    'setFullYear',
+    'setHours',
+    'setMilliseconds',
+    'setMinutes',
+    'setMonth',
+    'setSeconds',
+    'setTime',
+    'setUTCDate',
+    'setUTCFullYear',
+    'setUTCHours',
+    'setUTCMilliseconds',
+    'setUTCMinutes',
+    'setUTCMonth',
+    'setUTCSeconds',
+    'setYear',
+]);
+const TYPED_ARRAY_MUTATORS = new Set(['fill', 'set', 'copyWithin', 'sort', 'reverse']);
+const DATAVIEW_MUTATORS = new Set([
+    'setInt8',
+    'setUint8',
+    'setInt16',
+    'setUint16',
+    'setInt32',
+    'setUint32',
+    'setFloat32',
+    'setFloat64',
+    'setBigInt64',
+    'setBigUint64',
+]);
+function isTypedArray(obj) {
+    return (obj instanceof Int8Array ||
+        obj instanceof Uint8Array ||
+        obj instanceof Uint8ClampedArray ||
+        obj instanceof Int16Array ||
+        obj instanceof Uint16Array ||
+        obj instanceof Int32Array ||
+        obj instanceof Uint32Array ||
+        obj instanceof Float32Array ||
+        obj instanceof Float64Array ||
+        obj instanceof BigInt64Array ||
+        obj instanceof BigUint64Array);
+}
+function isMutatingMethod(obj, prop) {
+    if (typeof prop !== 'string')
+        return false;
+    if (obj instanceof Map)
+        return MAP_MUTATORS.has(prop);
+    if (obj instanceof WeakMap)
+        return WEAKMAP_MUTATORS.has(prop);
+    if (obj instanceof Set)
+        return SET_MUTATORS.has(prop);
+    if (obj instanceof WeakSet)
+        return WEAKSET_MUTATORS.has(prop);
+    if (obj instanceof Date)
+        return DATE_MUTATORS.has(prop);
+    if (obj instanceof DataView)
+        return DATAVIEW_MUTATORS.has(prop);
+    if (isTypedArray(obj))
+        return TYPED_ARRAY_MUTATORS.has(prop);
+    return false;
+}
+// Symbol for proxy metadata
+const PROXY_META = Symbol('proxy_meta');
+// Node.js inspection symbol
+const NODE_INSPECT = Symbol.for('nodejs.util.inspect.custom');
+// Well-known symbols that should pass through directly to target
+// These are used for introspection, iteration, type coercion, etc.
+const PASSTHROUGH_SYMBOLS = new Set([
+    Symbol.toStringTag,
+    Symbol.iterator,
+    Symbol.asyncIterator,
+    Symbol.toPrimitive,
+    Symbol.hasInstance,
+    Symbol.isConcatSpreadable,
+    Symbol.species,
+    Symbol.unscopables,
+    Symbol.match,
+    Symbol.matchAll,
+    Symbol.replace,
+    Symbol.search,
+    Symbol.split,
+    Symbol.dispose,
+    Symbol.asyncDispose,
+    NODE_INSPECT,
+]);
+// WeakMap to track original object -> proxy mapping (handles circular refs)
+const proxyCache = new WeakMap();
+const metaCache = new WeakMap();
+// Map root proxies to their dirty sets
+const rootDirtySetMap = new WeakMap();
+// Mark a container (like Map/Set/Date) and its parent paths as dirty
+// Unlike markDirtyWithParents, this doesn't add a sub-key
+function markContainerDirty(meta) {
+    const pathsWithDirtySets = collectPathsWithDirtySets(meta);
+    const modifiedDirtySets = new Set();
+    for (const { path, dirtySet } of pathsWithDirtySets) {
+        // Add the full path to this container
+        if (path.length > 0) {
+            dirtySet.add(path.join('.'));
+            modifiedDirtySets.add(dirtySet);
+        }
+        // Add parent paths
+        for (let i = path.length - 1; i > 0; i--) {
+            dirtySet.add(path.slice(0, i).join('.'));
+        }
+    }
+    for (const dirtySet of modifiedDirtySets) {
+        notifyWatchers(dirtySet);
+    }
+}
+function markDirtyWithParents(meta, key) {
+    // Collect all paths paired with their root's dirty set
+    const pathsWithDirtySets = collectPathsWithDirtySets(meta);
+    // Track which dirty sets were modified for notification
+    const modifiedDirtySets = new Set();
+    // Mark dirty only in the correct dirty set for each path
+    for (const { path: basePath, dirtySet } of pathsWithDirtySets) {
+        const fullPath = [...basePath, String(key)].join('.');
+        dirtySet.add(fullPath);
+        modifiedDirtySets.add(dirtySet);
+        // Also mark parent paths dirty
+        for (let i = basePath.length; i > 0; i--) {
+            dirtySet.add(basePath.slice(0, i).join('.'));
+        }
+    }
+    // Notify watchers for each modified dirty set
+    for (const dirtySet of modifiedDirtySets) {
+        notifyWatchers(dirtySet);
+    }
+}
+function collectPathsWithDirtySets(meta) {
+    const results = [];
+    // Use path string to dedupe (same path + same dirtySet = skip)
+    const seenPathDirtySet = new Map();
+    function traverse(current, pathSuffix, pathStack) {
+        // If this proxy was originally a root (observable/model), include its dirty set
+        const ownDirtySet = rootDirtySetMap.get(current);
+        if (ownDirtySet) {
+            const pathStr = pathSuffix.join('.');
+            let seenPaths = seenPathDirtySet.get(ownDirtySet);
+            if (!seenPaths) {
+                seenPaths = new Set();
+                seenPathDirtySet.set(ownDirtySet, seenPaths);
+            }
+            if (!seenPaths.has(pathStr)) {
+                results.push({ path: pathSuffix, dirtySet: ownDirtySet });
+                seenPaths.add(pathStr);
+            }
+        }
+        // If no parents, we're done with this branch
+        if (current.parents.size === 0) {
+            return;
+        }
+        // Continue traversing up to other roots via ALL parent paths
+        for (const parentRef of current.parents) {
+            const parent = parentRef.ref.deref();
+            if (!parent)
+                continue;
+            // Only skip if we'd create a cycle in THIS path
+            if (pathStack.includes(parent))
+                continue;
+            traverse(parent, [parentRef.key, ...pathSuffix], [...pathStack, parent]);
+        }
+    }
+    traverse(meta, [], [meta]);
+    // If no paths found (truly orphan proxy), use all dirty sets on this meta
+    if (results.length === 0) {
+        for (const dirtySet of meta.dirtySets) {
+            results.push({ path: [], dirtySet });
+        }
+    }
+    return results;
+}
+function addParentRef(meta, parent, key) {
+    // Check if this exact parent+key combo already exists
+    for (const existing of meta.parents) {
+        if (existing.ref.deref() === parent && existing.key === key) {
+            return; // Already registered
+        }
+    }
+    meta.parents.add({ ref: new WeakRef(parent), key });
+}
+// Propagate dirty sets down the tree (for cross-model sharing)
+function propagateDirtySets(meta, dirtySet) {
+    if (meta.dirtySets.has(dirtySet))
+        return;
+    meta.dirtySets.add(dirtySet);
+    // Propagate to all children
+    for (const childMeta of meta.children.values()) {
+        propagateDirtySets(childMeta, dirtySet);
+    }
+}
+export function createTrackedProxy(target, path, dirtySet, parent, keyInParent) {
+    // Check cache first (handles circular refs and cross-model sharing)
+    const cached = proxyCache.get(target);
+    if (cached) {
+        const cachedMeta = metaCache.get(cached);
+        if (cachedMeta) {
+            // Add the new dirty set (for cross-model sharing)
+            propagateDirtySets(cachedMeta, dirtySet);
+            if (parent && keyInParent) {
+                addParentRef(cachedMeta, parent, keyInParent);
+                parent.children.set(keyInParent, cachedMeta);
+            }
+        }
+        return cached;
+    }
+    const meta = {
+        path,
+        dirtySets: new Set([dirtySet]),
+        parents: new Set(parent && keyInParent ? [{ ref: new WeakRef(parent), key: keyInParent }] : []),
+        children: new Map(),
+        target,
+        proxy: null, // Will be set below
+    };
+    // If this is a root (no parent), register its dirty set
+    if (!parent) {
+        rootDirtySetMap.set(meta, dirtySet);
+    }
+    const proxy = new Proxy(target, {
+        get(obj, prop, receiver) {
+            // Handle our internal symbols - return directly from target
+            if (prop === MODEL_INTERNALS ||
+                prop === OBSERVABLE_META ||
+                prop === PROXY_META) {
+                return Reflect.get(obj, prop);
+            }
+            // Pass through well-known symbols for native behavior
+            // (iteration, inspection, type coercion, etc.)
+            if (typeof prop === 'symbol' && PASSTHROUGH_SYMBOLS.has(prop)) {
+                const value = Reflect.get(obj, prop, obj);
+                // Don't bind dispose functions - they may be non-configurable and
+                // the proxy must return the exact value to satisfy proxy invariants
+                if (prop === Symbol.dispose || prop === Symbol.asyncDispose) {
+                    return value;
+                }
+                // Bind other functions to target for proper behavior
+                if (typeof value === 'function') {
+                    return value.bind(obj);
+                }
+                return value;
+            }
+            // Built-ins with internal slots need to bypass proxy for all property access
+            // (both methods and getters like .size check internal slots)
+            if (hasInternalSlots(obj)) {
+                const value = Reflect.get(obj, prop, obj); // Use obj as receiver, not proxy
+                if (typeof value === 'function') {
+                    // Wrap mutating methods to track dirty
+                    if (isMutatingMethod(obj, prop)) {
+                        return function (...args) {
+                            const result = value.apply(obj, args);
+                            // Mark this built-in container and its parents as dirty
+                            markContainerDirty(meta);
+                            return result;
+                        };
+                    }
+                    return value.bind(obj);
+                }
+                return value;
+            }
+            const value = Reflect.get(obj, prop, receiver);
+            // Bind functions to the proxy so `this.foo = x` triggers dirty tracking
+            if (typeof value === 'function') {
+                return value.bind(proxy);
+            }
+            // Return cached child proxy if exists
+            if (meta.children.has(prop)) {
+                const childMeta = meta.children.get(prop);
+                return childMeta.proxy;
+            }
+            // Wrap objects/arrays in proxies
+            if (value !== null && typeof value === 'object') {
+                // Check if value is already a proxy (from another model/observable)
+                const existingMeta = metaCache.get(value);
+                if (existingMeta) {
+                    // Connect existing proxy to this tree
+                    addParentRef(existingMeta, meta, String(prop));
+                    meta.children.set(prop, existingMeta);
+                    // Propagate our dirty sets to the existing proxy
+                    for (const ds of meta.dirtySets) {
+                        propagateDirtySets(existingMeta, ds);
+                    }
+                    return existingMeta.proxy;
+                }
+                const childProxy = createTrackedProxy(value, [...path, String(prop)], dirtySet, meta, String(prop));
+                const childMeta = metaCache.get(childProxy);
+                if (childMeta) {
+                    meta.children.set(prop, childMeta);
+                }
+                return childProxy;
+            }
+            return value;
+        },
+        set(obj, prop, value, _receiver) {
+            const oldValue = Reflect.get(obj, prop, obj);
+            // Check if setting the same proxy reference back (no change)
+            const existingChild = meta.children.get(prop);
+            if (existingChild && existingChild.proxy === value) {
+                return true; // Same proxy, no change needed
+            }
+            // Clear old child tracking (for any value change, not just objects)
+            meta.children.delete(prop);
+            const result = Reflect.set(obj, prop, value, obj);
+            // Track dirty if value changed (including setting to undefined)
+            if (oldValue !== value) {
+                markDirtyWithParents(meta, prop);
+            }
+            return result;
+        },
+        deleteProperty(obj, prop) {
+            // Mark dirty BEFORE deleting so we can still traverse
+            markDirtyWithParents(meta, prop);
+            // Clean up child tracking
+            meta.children.delete(prop);
+            return Reflect.deleteProperty(obj, prop);
+        },
+        // Transparency traps - make proxy behave like native object
+        has(obj, prop) {
+            return Reflect.has(obj, prop);
+        },
+        ownKeys(obj) {
+            return Reflect.ownKeys(obj);
+        },
+        getOwnPropertyDescriptor(obj, prop) {
+            return Reflect.getOwnPropertyDescriptor(obj, prop);
+        },
+        getPrototypeOf(obj) {
+            return Reflect.getPrototypeOf(obj);
+        },
+        isExtensible(obj) {
+            return Reflect.isExtensible(obj);
+        },
+        preventExtensions(obj) {
+            return Reflect.preventExtensions(obj);
+        },
+        defineProperty(obj, prop, descriptor) {
+            const result = Reflect.defineProperty(obj, prop, descriptor);
+            // Don't mark internal symbols as dirty
+            if (result &&
+                'value' in descriptor &&
+                prop !== MODEL_INTERNALS &&
+                prop !== OBSERVABLE_META &&
+                prop !== Symbol.dispose &&
+                prop !== Symbol.asyncDispose) {
+                markDirtyWithParents(meta, prop);
+            }
+            return result;
+        },
+        setPrototypeOf(obj, proto) {
+            return Reflect.setPrototypeOf(obj, proto);
+        },
+    });
+    meta.proxy = proxy;
+    proxyCache.set(target, proxy);
+    metaCache.set(proxy, meta);
+    return proxy;
+}
+// Get proxy metadata (for debugging/testing)
+export function getProxyMeta(proxy) {
+    return metaCache.get(proxy);
+}
+// Check if an object is already a tracked proxy
+export function isTrackedProxy(obj) {
+    return obj !== null && typeof obj === 'object' && metaCache.has(obj);
+}
+//# sourceMappingURL=proxy.js.map