@justscale/core 0.1.0

package/dist/models/scheduled-task/scheduled-task.repository.d.ts

@@ -0,0 +1,150 @@
+/**
+ * ScheduledTaskRepository
+ *
+ * Abstract repository for scheduled tasks. Extends ModelRepository with
+ * scheduling-specific methods.
+ *
+ * Implementations (PostgreSQL, Redis, in-memory) provide:
+ * - Durable storage of scheduled tasks
+ * - Exactly-once pickup semantics via locking
+ * - Subscription for task delivery via async iteration
+ *
+ * @example
+ * ```typescript
+ * // Schedule a task
+ * const task = await scheduler.schedule({
+ *   dueAt: new Date(Date.now() + 60_000),
+ *   namespace: 'process',
+ *   type: 'delay',
+ *   payload: { processId: 'abc' },
+ * })
+ *
+ * // Cancel if needed
+ * await scheduler.cancel(task.id)
+ *
+ * // Subscribe and process tasks
+ * for await (const task of scheduler.subscribe('process.delay')) {
+ *   await handleTask(task)
+ * }
+ * ```
+ */
+import { ModelRepository } from '../model.repository.js';
+import type { Persistent } from '../types.js';
+import { ScheduledTask } from './scheduled-task.js';
+/**
+ * Options for scheduling a task.
+ */
+export interface ScheduleOptions<TPayload = unknown> {
+    /** When the task should be executed */
+    dueAt: Date;
+    /** Task namespace (e.g., 'process', 'email') */
+    namespace: string;
+    /** Task type within namespace (e.g., 'delay', 'reminder') */
+    type: string;
+    /** Task payload data */
+    payload: TPayload;
+}
+/**
+ * Abstract repository for scheduled tasks.
+ *
+ * Extends ModelRepository<ScheduledTask> with scheduling-specific operations.
+ * Implementations handle the actual storage and delivery mechanism.
+ */
+export declare abstract class ScheduledTaskRepository extends ModelRepository<ScheduledTask> {
+    /**
+     * Schedule a new task.
+     *
+     * Creates a task that will be delivered to subscribers of the qualified name
+     * (namespace.type) when the dueAt time is reached.
+     *
+     * @param options - Task scheduling options
+     * @returns The created task with ID and metadata
+     *
+     * @example
+     * ```typescript
+     * const task = await scheduler.schedule({
+     *   dueAt: new Date(Date.now() + hours(24).ms),
+     *   namespace: 'process',
+     *   type: 'delay',
+     *   payload: { processId: '123', instanceId: 'abc' },
+     * })
+     * ```
+     */
+    abstract schedule<TPayload = unknown>(options: ScheduleOptions<TPayload>): Promise<Persistent<ScheduledTask>>;
+    /**
+     * Cancel a scheduled task.
+     *
+     * Can only cancel tasks that are still pending (not yet picked up).
+     *
+     * @param taskId - The task ID to cancel
+     * @returns true if cancelled, false if not found or already processing
+     *
+     * @example
+     * ```typescript
+     * const cancelled = await scheduler.cancel(task.id)
+     * if (!cancelled) {
+     *   console.log('Task already started or not found')
+     * }
+     * ```
+     */
+    abstract cancel(taskId: string): Promise<boolean>;
+    /**
+     * Subscribe to tasks by qualified name.
+     *
+     * Returns an async iterable that yields tasks as they become due.
+     * Each task is yielded to exactly one subscriber (exactly-once delivery).
+     *
+     * The implementation handles:
+     * - Polling or push-based delivery (implementation-specific)
+     * - Locking to ensure exactly-once pickup
+     * - Marking tasks as completed after successful processing
+     *
+     * To stop subscribing, break out of the loop or use AbortController.
+     *
+     * @param qualifiedName - The namespace.type to subscribe to (e.g., 'process.delay')
+     * @param options - Optional subscription options
+     * @returns Async iterable of tasks
+     *
+     * @example
+     * ```typescript
+     * // Basic subscription
+     * for await (const task of scheduler.subscribe('process.delay')) {
+     *   await resumeProcess(task.payload as ProcessPayload)
+     *   // Task is automatically marked completed after successful handling
+     * }
+     *
+     * // With abort controller for graceful shutdown
+     * const controller = new AbortController()
+     * process.on('SIGTERM', () => controller.abort())
+     *
+     * for await (const task of scheduler.subscribe('process.delay', {
+     *   signal: controller.signal,
+     * })) {
+     *   await handleTask(task)
+     * }
+     * ```
+     */
+    abstract subscribe(qualifiedName: string, options?: SubscribeOptions): AsyncIterable<Persistent<ScheduledTask>>;
+}
+/**
+ * Options for subscribing to tasks.
+ */
+export interface SubscribeOptions {
+    /** AbortSignal for graceful shutdown */
+    signal?: AbortSignal;
+    /** Polling interval in ms (for polling-based implementations) */
+    pollInterval?: number;
+    /**
+     * Reset tasks stuck in Processing status longer than this many ms back
+     * to Pending so they can be re-delivered. Guards against worker crashes
+     * that leave rows claimed but never completed. Defaults to 10 minutes;
+     * pass a number to override or `false` to disable auto-recovery.
+     */
+    stuckAfterMs?: number | false;
+    /**
+     * How often to check for stuck tasks (ms). Defaults to 60_000 (once per
+     * minute); ignored when `stuckAfterMs: false`.
+     */
+    stuckCheckEveryMs?: number;
+}
+//# sourceMappingURL=scheduled-task.repository.d.ts.map

package/dist/models/scheduled-task/scheduled-task.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-task.repository.d.ts","sourceRoot":"","sources":["../../../src/models/scheduled-task/scheduled-task.repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,QAAQ,GAAG,OAAO;IACjD,uCAAuC;IACvC,KAAK,EAAE,IAAI,CAAA;IACX,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAA;IACjB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IACZ,wBAAwB;IACxB,OAAO,EAAE,QAAQ,CAAA;CAClB;AAED;;;;;GAKG;AACH,8BAAsB,uBAAwB,SAAQ,eAAe,CAAC,aAAa,CAAC;IAClF;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,QAAQ,CAAC,QAAQ,GAAG,OAAO,EAClC,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,GACjC,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,QAAQ,CAAC,SAAS,CAChB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,aAAa,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,wCAAwC;IACxC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,KAAK,CAAA;IAC7B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B"}

package/dist/models/scheduled-task/scheduled-task.repository.js

@@ -0,0 +1,40 @@
+/**
+ * ScheduledTaskRepository
+ *
+ * Abstract repository for scheduled tasks. Extends ModelRepository with
+ * scheduling-specific methods.
+ *
+ * Implementations (PostgreSQL, Redis, in-memory) provide:
+ * - Durable storage of scheduled tasks
+ * - Exactly-once pickup semantics via locking
+ * - Subscription for task delivery via async iteration
+ *
+ * @example
+ * ```typescript
+ * // Schedule a task
+ * const task = await scheduler.schedule({
+ *   dueAt: new Date(Date.now() + 60_000),
+ *   namespace: 'process',
+ *   type: 'delay',
+ *   payload: { processId: 'abc' },
+ * })
+ *
+ * // Cancel if needed
+ * await scheduler.cancel(task.id)
+ *
+ * // Subscribe and process tasks
+ * for await (const task of scheduler.subscribe('process.delay')) {
+ *   await handleTask(task)
+ * }
+ * ```
+ */
+import { ModelRepository } from '../model.repository.js';
+/**
+ * Abstract repository for scheduled tasks.
+ *
+ * Extends ModelRepository<ScheduledTask> with scheduling-specific operations.
+ * Implementations handle the actual storage and delivery mechanism.
+ */
+export class ScheduledTaskRepository extends ModelRepository {
+}
+//# sourceMappingURL=scheduled-task.repository.js.map

package/dist/models/scheduled-task/scheduled-task.repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-task.repository.js","sourceRoot":"","sources":["../../../src/models/scheduled-task/scheduled-task.repository.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAkBzD;;;;;GAKG;AACH,MAAM,OAAgB,uBAAwB,SAAQ,eAA8B;CAkFnF"}

package/dist/models/stream.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Stream Field Implementation
+ *
+ * Provides pub/sub streams as first-class model fields.
+ * Streams are AsyncIterable<T> for subscription and have a publish() method.
+ *
+ * @example
+ * ```typescript
+ * const Room = defineModel('Room', {
+ *   name: field.string(),
+ *   messages: field.stream(ChatMessage),
+ * })
+ *
+ * // Subscribe
+ * for await (const msg of room.messages) {
+ *   console.log(msg.text)
+ * }
+ *
+ * // Publish
+ * room.messages.publish({ user: userRef, text: 'hello' })
+ * ```
+ */
+import type { ChannelSubscription } from '../features/channel/types.js';
+/** Symbol to mark an object as a Stream */
+export declare const STREAM: unique symbol;
+/** Symbol-keyed method to attach channel (internal use by repository) */
+export declare const SET_STREAM_CHANNEL: unique symbol;
+/** Symbol-keyed method to attach signal emitter for process wakeup */
+export declare const SET_STREAM_SIGNAL_EMITTER: unique symbol;
+/**
+ * A stream field that provides pub/sub messaging on a model.
+ *
+ * Implements AsyncIterable<T> for subscription via `for await...of`.
+ * Provides publish() method for broadcasting messages.
+ * Implements Disposable for cleanup via `using` syntax.
+ *
+ * @example
+ * ```typescript
+ * // Subscribe to messages
+ * for await (const msg of room.messages) {
+ *   console.log(msg.text)
+ * }
+ *
+ * // Publish a message
+ * room.messages.publish({ user: userRef, text: 'hello' })
+ *
+ * // Manual cleanup (or use `using` on entity)
+ * room.messages.disconnect()
+ * ```
+ */
+export interface Stream<T> extends AsyncIterable<T>, Disposable {
+    readonly [STREAM]: true;
+    /**
+     * Async iterator - enables `for await (const msg of stream) { ... }`
+     * Delegates to underlying channel's async iterator.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    /**
+     * Publish a message to all subscribers.
+     *
+     * For protected streams, requires the entity to be locked.
+     *
+     * @throws Error if stream is not connected (entity not from repository)
+     * @throws Error if stream is protected and entity is not locked
+     */
+    publish(message: T): void;
+    /** Check if stream has active channel connection */
+    readonly isConnected: boolean;
+    /**
+     * Disconnect from the channel and clean up resources.
+     * Safe to call multiple times.
+     */
+    disconnect(): void;
+}
+/**
+ * Stream implementation that wraps a channel subscription.
+ * Created by repository during entity hydration.
+ */
+export declare class StreamImpl<T> implements Stream<T> {
+    readonly [STREAM]: true;
+    private channel;
+    private publishFn;
+    private readonly protectedMode;
+    private lockChecker;
+    /** Signal emitter for waking up processes waiting on stream() */
+    private signalEmitter;
+    /** Channel key for signal emission (tableName:entityId:fieldName) */
+    private channelKey;
+    constructor(isProtected: boolean);
+    /**
+     * Attach the channel subscription and publish function.
+     * Called by repository during entity hydration.
+     *
+     * @internal
+     */
+    [SET_STREAM_CHANNEL](channel: ChannelSubscription<T>, publish: (msg: T) => void, lockChecker?: () => boolean): void;
+    /**
+     * Attach a signal emitter for process wakeup.
+     * When publish() is called, this emitter is invoked to wake up any
+     * processes that are suspended on stream(r, entity.field).
+     *
+     * Called by repository during entity hydration when SignalBus is available.
+     *
+     * @internal
+     */
+    [SET_STREAM_SIGNAL_EMITTER](channelKey: string, emitter: (channelKey: string, message: T) => void): void;
+    /**
+     * Async generator that delegates to the channel's async iterator.
+     * Uses `yield*` to forward all messages from the underlying channel.
+     */
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    publish(message: T): void;
+    get isConnected(): boolean;
+    /**
+     * Disconnect from the channel and clean up resources.
+     * Unsubscribes from the underlying channel subscription.
+     * Safe to call multiple times.
+     */
+    disconnect(): void;
+    /**
+     * Disposable implementation for `using` syntax.
+     * Automatically cleans up when the stream goes out of scope.
+     */
+    [Symbol.dispose](): void;
+}
+/**
+ * Check if a value is a Stream.
+ *
+ * @example
+ * ```typescript
+ * if (isStream(value)) {
+ *   for await (const msg of value) {
+ *     console.log(msg)
+ *   }
+ * }
+ * ```
+ */
+export declare function isStream(value: unknown): value is Stream<unknown>;
+//# sourceMappingURL=stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/models/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAMxE,2CAA2C;AAC3C,eAAO,MAAM,MAAM,eAA0B,CAAC;AAE9C,yEAAyE;AACzE,eAAO,MAAM,kBAAkB,eAAqC,CAAC;AAErE,sEAAsE;AACtE,eAAO,MAAM,yBAAyB,eAA2C,CAAC;AAMlF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC,EAAE,UAAU;IAC7D,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,IAAI,CAAA;IAEvB;;;OAGG;IACH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAA;IAE1C;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAA;IAEzB,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAE7B;;;OAGG;IACH,UAAU,IAAI,IAAI,CAAA;CACnB;AAMD;;;GAGG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAC7C,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAG,IAAI,CAAU;IAElC,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,SAAS,CAAmC;IACpD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IACxC,OAAO,CAAC,WAAW,CAAgC;IAEnD,iEAAiE;IACjE,OAAO,CAAC,aAAa,CAA2D;IAChF,qEAAqE;IACrE,OAAO,CAAC,UAAU,CAAuB;gBAE7B,WAAW,EAAE,OAAO;IAIhC;;;;;OAKG;IACH,CAAC,kBAAkB,CAAC,CAClB,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC/B,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EACzB,WAAW,CAAC,EAAE,MAAM,OAAO,GAC1B,IAAI;IAMP;;;;;;;;OAQG;IACH,CAAC,yBAAyB,CAAC,CACzB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,IAAI,GAChD,IAAI;IAKP;;;OAGG;IACI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;IASjD,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAuBzB,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED;;;;OAIG;IACH,UAAU,IAAI,IAAI;IAWlB;;;OAGG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGzB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,OAAO,CAAC,CAEjE"}

package/dist/models/stream.js

@@ -0,0 +1,153 @@
+/**
+ * Stream Field Implementation
+ *
+ * Provides pub/sub streams as first-class model fields.
+ * Streams are AsyncIterable<T> for subscription and have a publish() method.
+ *
+ * @example
+ * ```typescript
+ * const Room = defineModel('Room', {
+ *   name: field.string(),
+ *   messages: field.stream(ChatMessage),
+ * })
+ *
+ * // Subscribe
+ * for await (const msg of room.messages) {
+ *   console.log(msg.text)
+ * }
+ *
+ * // Publish
+ * room.messages.publish({ user: userRef, text: 'hello' })
+ * ```
+ */
+// ============================================================================
+// Symbols
+// ============================================================================
+/** Symbol to mark an object as a Stream */
+export const STREAM = Symbol('models:stream');
+/** Symbol-keyed method to attach channel (internal use by repository) */
+export const SET_STREAM_CHANNEL = Symbol('models:stream:setChannel');
+/** Symbol-keyed method to attach signal emitter for process wakeup */
+export const SET_STREAM_SIGNAL_EMITTER = Symbol('models:stream:setSignalEmitter');
+// ============================================================================
+// Stream Implementation
+// ============================================================================
+/**
+ * Stream implementation that wraps a channel subscription.
+ * Created by repository during entity hydration.
+ */
+export class StreamImpl {
+    [STREAM] = true;
+    channel = null;
+    publishFn = null;
+    protectedMode;
+    lockChecker = null;
+    /** Signal emitter for waking up processes waiting on stream() */
+    signalEmitter = null;
+    /** Channel key for signal emission (tableName:entityId:fieldName) */
+    channelKey = null;
+    constructor(isProtected) {
+        this.protectedMode = isProtected;
+    }
+    /**
+     * Attach the channel subscription and publish function.
+     * Called by repository during entity hydration.
+     *
+     * @internal
+     */
+    [SET_STREAM_CHANNEL](channel, publish, lockChecker) {
+        this.channel = channel;
+        this.publishFn = publish;
+        this.lockChecker = lockChecker ?? null;
+    }
+    /**
+     * Attach a signal emitter for process wakeup.
+     * When publish() is called, this emitter is invoked to wake up any
+     * processes that are suspended on stream(r, entity.field).
+     *
+     * Called by repository during entity hydration when SignalBus is available.
+     *
+     * @internal
+     */
+    [SET_STREAM_SIGNAL_EMITTER](channelKey, emitter) {
+        this.channelKey = channelKey;
+        this.signalEmitter = emitter;
+    }
+    /**
+     * Async generator that delegates to the channel's async iterator.
+     * Uses `yield*` to forward all messages from the underlying channel.
+     */
+    async *[Symbol.asyncIterator]() {
+        if (!this.channel) {
+            throw new Error('Stream not connected. Ensure entity is loaded via repository.');
+        }
+        // Delegate to channel's async iterator
+        // Channel's [Symbol.asyncIterator] yields messages as they arrive.
+        yield* this.channel;
+    }
+    publish(message) {
+        if (!this.publishFn) {
+            throw new Error('Stream not connected. Ensure entity is loaded via repository.');
+        }
+        if (this.protectedMode && this.lockChecker && !this.lockChecker()) {
+            throw new Error('Protected stream requires Lock<T> to publish.');
+        }
+        // Publish to local subscribers (channel)
+        this.publishFn(message);
+        // Emit signal for process wakeup (if configured)
+        // This wakes up any processes waiting on stream(r, entity.field)
+        if (this.signalEmitter && this.channelKey) {
+            try {
+                this.signalEmitter(this.channelKey, message);
+            }
+            catch (err) {
+                // Don't let signal emission failure break the publish
+                console.error('[Stream] Signal emission failed:', err);
+            }
+        }
+    }
+    get isConnected() {
+        return this.channel !== null && this.publishFn !== null;
+    }
+    /**
+     * Disconnect from the channel and clean up resources.
+     * Unsubscribes from the underlying channel subscription.
+     * Safe to call multiple times.
+     */
+    disconnect() {
+        if (this.channel) {
+            this.channel.unsubscribe();
+            this.channel = null;
+        }
+        this.publishFn = null;
+        this.lockChecker = null;
+        this.signalEmitter = null;
+        this.channelKey = null;
+    }
+    /**
+     * Disposable implementation for `using` syntax.
+     * Automatically cleans up when the stream goes out of scope.
+     */
+    [Symbol.dispose]() {
+        this.disconnect();
+    }
+}
+// ============================================================================
+// Type Guards
+// ============================================================================
+/**
+ * Check if a value is a Stream.
+ *
+ * @example
+ * ```typescript
+ * if (isStream(value)) {
+ *   for await (const msg of value) {
+ *     console.log(msg)
+ *   }
+ * }
+ * ```
+ */
+export function isStream(value) {
+    return typeof value === 'object' && value !== null && STREAM in value;
+}
+//# sourceMappingURL=stream.js.map

package/dist/models/stream.js.map

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

package/dist/models/symbols.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Symbols for internal metadata on models.
+ *
+ * Most use plain Symbol() to avoid cross-version collisions - each
+ * package version has its own symbols, so mismatched metadata shapes
+ * never cause silent data corruption. Cross-module symbols that must
+ * survive HMR use Symbol.for() instead.
+ */
+/** Symbol to access model internals (schema, dirty tracking, etc.) */
+export declare const MODEL_INTERNALS: unique symbol;
+/** Symbol to access observable internals (dirty tracking, etc.) */
+export declare const OBSERVABLE_META: unique symbol;
+/** Symbol to mark an object as a Reference */
+export declare const REFERENCE: unique symbol;
+/** Symbol to mark an object as a References collection */
+export declare const REFERENCES: unique symbol;
+/** Symbol for internal reference ID storage */
+export declare const REF_ID: unique symbol;
+/** Symbol for internal reference IDs storage (plural) */
+export declare const REF_IDS: unique symbol;
+/** Symbol for cached resolved value */
+export declare const REF_VALUE: unique symbol;
+/** Symbol for cached resolved values (plural) */
+export declare const REF_VALUES: unique symbol;
+/** Symbol for resolver function */
+export declare const REF_RESOLVER: unique symbol;
+/** Symbol-keyed method to attach resolver (internal use) */
+export declare const SET_RESOLVER: unique symbol;
+/** Symbol-keyed method to hydrate a reference with a pre-loaded value (internal use) */
+export declare const HYDRATE: unique symbol;
+/** Symbol to mark an object as a TransientRef */
+export declare const TRANSIENT_REF: unique symbol;
+/** Symbol for internal transient target storage */
+export declare const TRANSIENT_TARGET: unique symbol;
+/** Symbol to mark an instance as persisted (stored by an adapter) */
+export declare const PERSISTENT: unique symbol;
+/** Symbol for adapter-stored key on a persistent entity (non-enumerable) */
+export declare const ADAPTER_KEY: unique symbol;
+/** Symbol to mark an instance as transient (not yet saved) */
+export declare const TRANSIENT: unique symbol;
+/** Symbol to mark an instance as locked (for safe mutations) */
+export declare const LOCK: unique symbol;
+/** Symbol for internal field storage on model instances */
+export declare const FIELD_STORAGE: unique symbol;
+/** Symbol for model context (registry, resolvers, etc.) */
+export declare const MODEL_CONTEXT: unique symbol;
+/** Symbol for model methods (type-level only, for extraction by Persistent/Transient) */
+export declare const MODEL_METHODS: unique symbol;
+/** Symbol to store the base model on a repository token */
+export declare const MODEL_REPO_MODEL: unique symbol;
+/** Symbol for custom repository that links to base ModelRepository token */
+export declare const MODEL_REPO_BASE_TOKEN: unique symbol;
+/** Symbol for storage model factory (creates repository from deps) */
+export declare const CREATE_MODEL_REPO: unique symbol;
+/** Symbol to store custom repository contract type on a model */
+export declare const MODEL_REPO_CONTRACT: unique symbol;
+/** Symbol to store field-level access rules on a model class */
+export declare const ACCESS_RULES: unique symbol;
+/** Symbol to store the raw permission defs record on a model class (for access rule evaluation) */
+export declare const PERMISSION_DEFS: unique symbol;
+/**
+ * Symbol to store inject config on a model class.
+ * Contains the raw { key: ServiceToken } map from defineModel({ inject }).
+ * Symbol.for() for cross-module matching.
+ */
+export declare const MODEL_INJECT: unique symbol;
+/**
+ * Symbol to store the resolved model service on a model class.
+ * The model service is Object.create(ModelClass.prototype) with resolved inject deps.
+ * Set during boot by Container.wireModelPrototypes().
+ */
+export declare const MODEL_SERVICE: unique symbol;
+//# sourceMappingURL=symbols.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.d.ts","sourceRoot":"","sources":["../../src/models/symbols.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,sEAAsE;AACtE,eAAO,MAAM,eAAe,eAA4B,CAAC;AAEzD,mEAAmE;AACnE,eAAO,MAAM,eAAe,eAA4B,CAAC;AAMzD,8CAA8C;AAC9C,eAAO,MAAM,SAAS,eAA6B,CAAC;AAEpD,0DAA0D;AAC1D,eAAO,MAAM,UAAU,eAA8B,CAAC;AAEtD,+CAA+C;AAC/C,eAAO,MAAM,MAAM,eAA0B,CAAC;AAE9C,yDAAyD;AACzD,eAAO,MAAM,OAAO,eAA4B,CAAC;AAEjD,uCAAuC;AACvC,eAAO,MAAM,SAAS,eAA6B,CAAC;AAEpD,iDAAiD;AACjD,eAAO,MAAM,UAAU,eAA+B,CAAC;AAEvD,mCAAmC;AACnC,eAAO,MAAM,YAAY,eAAgC,CAAC;AAE1D,4DAA4D;AAC5D,eAAO,MAAM,YAAY,eAAmC,CAAC;AAE7D,wFAAwF;AACxF,eAAO,MAAM,OAAO,eAA+B,CAAC;AAMpD,iDAAiD;AACjD,eAAO,MAAM,aAAa,eAAgC,CAAC;AAE3D,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,eAAuC,CAAC;AAMrE,qEAAqE;AACrE,eAAO,MAAM,UAAU,eAA8B,CAAC;AAEtD,4EAA4E;AAC5E,eAAO,MAAM,WAAW,eAA8B,CAAC;AAEvD,8DAA8D;AAC9D,eAAO,MAAM,SAAS,eAA6B,CAAC;AAEpD,gEAAgE;AAChE,eAAO,MAAM,IAAI,eAAwB,CAAC;AAM1C,2DAA2D;AAC3D,eAAO,MAAM,aAAa,eAAgC,CAAC;AAE3D,2DAA2D;AAC3D,eAAO,MAAM,aAAa,eAAgC,CAAC;AAE3D,yFAAyF;AACzF,eAAO,MAAM,aAAa,eAAgC,CAAC;AAM3D,2DAA2D;AAC3D,eAAO,MAAM,gBAAgB,eAAkC,CAAC;AAEhE,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,eAAsC,CAAC;AAEzE,sEAAsE;AACtE,eAAO,MAAM,iBAAiB,eAAmC,CAAC;AAElE,iEAAiE;AACjE,eAAO,MAAM,mBAAmB,eAAqC,CAAC;AAMtE,gEAAgE;AAChE,eAAO,MAAM,YAAY,eAA+B,CAAC;AAEzD,mGAAmG;AACnG,eAAO,MAAM,eAAe,eAAkC,CAAC;AAM/D;;;;GAIG;AACH,eAAO,MAAM,YAAY,eAAmD,CAAC;AAE7E;;;;GAIG;AACH,eAAO,MAAM,aAAa,eAAoD,CAAC"}