@anchorlib/svelte 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/index.d.ts

@@ -1,304 +1,12 @@
-import { LinkableSchema, StateOptions, ModelInput, ModelOutput, Immutable, ModelArray, Linkable, FetchOptions, FetchState, StreamOptions, State, HistoryOptions, HistoryState, StateBaseOptions, ImmutableOutput, Mutable, MutationKey, MutablePart, ObjLike, StateExceptionMap, KeyLike } from '@anchorlib/core';
-import { V as VariableRef, C as ConstantRef, S as StateRef } from './types-CsfltB4A.js';
-export { R as RefSubscriber, a as RefUnsubscribe } from './types-CsfltB4A.js';
-import { Readable } from 'svelte/store';
-
-/**
- * Creates a writable reference that can be used to manage state with Anchor.
- * This overload is used when no schema is provided, or when using a LinkableSchema with StateOptions.
- *
- * @template T - The type of the initial value
- * @template S - The schema type, extending LinkableSchema
- * @param init - The initial value for the reference
- * @param options - Optional state options for the reference
- * @returns A WritableRef containing the initial value
- */
-declare function anchorRef<T, S extends LinkableSchema = LinkableSchema>(init: T, options?: StateOptions<S>): VariableRef<T>;
-/**
- * Creates a writable reference with a defined schema for validation and type inference.
- *
- * @template S - The schema type, extending LinkableSchema
- * @template T - The type of the initial value, must extend ModelInput of the schema
- * @param init - The initial value for the reference
- * @param schema - The schema to validate and type the reference
- * @param options - Optional state options for the reference
- * @returns A WritableRef containing the output model based on the schema
- */
-declare function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions): VariableRef<ModelOutput<S>>;
-/**
- * Creates an immutable writable reference with a defined schema.
- *
- * @template S - The schema type, extending LinkableSchema
- * @template T - The type of the initial value, must extend ModelInput of the schema
- * @param init - The initial value for the reference
- * @param schema - The schema to validate and type the reference
- * @param options - State options with immutable flag set to true
- * @returns A WritableRef containing an immutable output model based on the schema
- */
-declare function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions & {
-    immutable: true;
-}): VariableRef<Immutable<ModelOutput<S>>>;
-/**
- * Creates a writable reference that maintains a sorted array state based on a comparison function.
- *
- * @template T - The type of elements in the array
- * @template S - The schema type for array elements, extending ModelArray
- * @param init - The initial array value for the reference
- * @param compare - A function that defines the sort order of elements
- * @param options - Optional state options for the reference
- * @returns A VariableRef containing the sorted array
- */
-declare function orderedRef<T extends unknown[], S extends ModelArray = ModelArray>(init: T, compare: (a: T[number], b: T[number]) => number, options?: StateOptions<S>): VariableRef<T>;
-/**
- * Creates a writable reference that maintains a flat array state.
- *
- * @template T - The type of elements in the array
- * @template S - The schema type for array elements, extending ModelArray
- * @param init - The initial array value for the reference
- * @param options - Optional state options for the reference
- * @returns A VariableRef containing the flat array
- */
-declare function flatRef<T extends unknown[], S extends ModelArray = ModelArray>(init: T, options?: StateOptions<S>): VariableRef<T>;
-/**
- * Creates a writable reference that mutates the underlying object.
- *
- * Unless you set the global options to `cloned: true`, you don't want to use this.
- *
- * @template T - The type of the initial value
- * @template S - The schema type, extending LinkableSchema
- * @param init - The initial value for the reference
- * @param options - Optional state options for the reference
- * @returns A VariableRef containing the raw value
- */
-declare function rawRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(init: T, options?: StateOptions<S>): VariableRef<T>;
-
-/**
- * Creates a derived store from a state or a writable reference.
- *
- * @template T - The type of the input state
- * @template R - The type of the transformed output
- * @param state - The input state or writable reference
- * @param recursive - A boolean indicating whether to recursively derive the state
- * @returns A readable store containing the state value
- */
-declare function derivedRef<T>(state: T | VariableRef<T>, recursive?: boolean): Readable<T>;
-/**
- * Creates a derived store from a state or a writable reference with transformation.
- *
- * @template T - The type of the input state
- * @template R - The type of the transformed output
- * @param state - The input state or writable reference
- * @param transform - A function that transforms the current state value
- * @returns A readable store containing the transformed value
- */
-declare function derivedRef<T, R>(state: T | VariableRef<T>, transform: (current: T) => R): Readable<R>;
-
-/**
- * Creates a readable Svelte store that manages the state of a fetch request.
- * This overload is for GET or DELETE requests, which typically do not have a request body.
- *
- * @template R The type of the data expected in the response.
- * @param init The initial value for the fetch state.
- * @param options The options for the fetch request, including the URL and method.
- * @returns A `ReadableRef` containing the `FetchState` of the request.
- */
-declare function fetchRef<R>(init: R, options: FetchOptions & {
-    method: 'GET' | 'DELETE';
-}): ConstantRef<FetchState<R>>;
-/**
- * Creates a readable Svelte store that manages the state of a fetch request.
- * This overload is for POST, PUT, or PATCH requests, which typically include a request body.
- *
- * @template R The type of the data expected in the response.
- * @template P The type of the request body.
- * @param init The initial value for the fetch state.
- * @param options The options for the fetch request, including the URL, method, and body.
- * @returns A `ReadableRef` containing the `FetchState` of the request.
- */
-declare function fetchRef<R, P>(init: R, options: FetchOptions & {
-    method: 'POST' | 'PUT' | 'PATCH';
-    body: P;
-}): ConstantRef<FetchState<R>>;
-/**
- * Creates a readable Svelte store that manages the state of a streaming request.
- * This overload is for GET or DELETE requests, which typically do not have a request body.
- *
- * @template R The type of the data expected in the response.
- * @param init The initial value for the fetch state.
- * @param options The options for the stream request, including the URL and method.
- * @returns A `ReadableRef` containing the `FetchState` of the request.
- */
-declare function streamRef<R>(init: R, options: StreamOptions<R> & {
-    method: 'GET' | 'DELETE';
-}): ConstantRef<FetchState<R>>;
-/**
- * Creates a readable Svelte store that manages the state of a streaming request.
- * This overload is for POST, PUT, or PATCH requests, which typically include a request body.
- *
- * @template R The type of the data expected in the response.
- * @template P The type of the request body.
- * @param init The initial value for the fetch state.
- * @param options The options for the stream request, including the URL, method, and body.
- * @returns A `ReadableRef` containing the `FetchState` of the request.
- */
-declare function streamRef<R, P>(init: R, options: StreamOptions<R> & {
-    method: 'POST' | 'PUT' | 'PATCH';
-    body: P;
-}): ConstantRef<FetchState<R>>;
-
-/**
- * Creates a readable Svelte store that reflects the history state of a given Anchor state.
- * @param state The initial Anchor state.
- * @param options Optional history options.
- * @returns A readable Svelte store containing the history state.
- */
-declare function historyRef<T extends State>(state: T, options?: HistoryOptions): ConstantRef<HistoryState>;
-
-/**
- * Creates an immutable ref from a state object.
- *
- * @template T The type of the state object.
- * @template S The type of the linkable schema.
- * @param init The initial state object.
- * @param options Optional state options.
- * @returns A VariableRef containing the immutable state.
- */
-declare function immutableRef<T extends State, S extends LinkableSchema = LinkableSchema>(init: T, options?: StateOptions<S>): VariableRef<Immutable<T>>;
-/**
- * Creates an immutable ref from a model input and a schema.
- *
- * @template S The type of the linkable schema.
- * @template T The type of the model input.
- * @param init The initial model input.
- * @param schema The linkable schema.
- * @param options Optional base state options.
- * @returns A VariableRef containing the immutable output of the schema.
- */
-declare function immutableRef<S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema: S, options?: StateBaseOptions): VariableRef<ImmutableOutput<S>>;
-/**
- * Creates a writable ref from a state object.
- *
- * @template T The type of the state object.
- * @param state The initial state object.
- * @returns A ConstantRef containing the mutable state.
- */
-declare function writableRef<T extends State>(state: T): ConstantRef<Mutable<T>>;
-/**
- * Creates a writable ref from a state object and a list of contracts.
- *
- * @template T The type of the state object.
- * @template K The type of the mutation keys.
- * @param state The initial state object.
- * @param contracts A list of mutation keys.
- * @returns A ConstantRef containing the mutable part of the state.
- */
-declare function writableRef<T extends State, K extends MutationKey<T>[]>(state: T, contracts: K): VariableRef<MutablePart<T, K>>;
-
-/**
- * Creates a model reference with mutable state.
- *
- * @template S - The linkable schema type
- * @template T - The model input type that extends the schema
- * @param schema - The schema to use for the model
- * @param init - The initial value for the model
- * @param options - Optional state configuration
- * @returns A variable reference containing the model output
- */
-declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options?: StateBaseOptions): VariableRef<ModelOutput<S>>;
-/**
- * Creates a model reference with immutable state.
- *
- * @template S - The linkable schema type
- * @template T - The model input type that extends the schema
- * @param schema - The schema to use for the model
- * @param init - The initial value for the model
- * @param options - State configuration with immutable flag set to true
- * @returns A variable reference containing the immutable output
- */
-declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options: StateBaseOptions & {
-    immutable: true;
-}): VariableRef<ImmutableOutput<S>>;
-/**
- * Creates a constant reference that maps exceptions for a given state object or array.
- *
- * @template T - The type of the input state, must be an object-like or array type
- * @param state - The input state object or array to create exception mappings for
- * @returns A ConstantRef containing the StateExceptionMap for the provided state
- */
-declare function exceptionRef<T extends ObjLike | Array<unknown>>(state: T | VariableRef<T>): ConstantRef<StateExceptionMap<T>>;
-
-type Props = {
-    [key: string]: KeyLike | State;
-};
-type PropsRef<T extends Props> = {
-    [K in keyof T]: T[K] extends State ? ConstantRef<T[K]> : T[K];
-};
-/**
- * Creates a reactive reference object from the provided props.
- * For each property in the input props:
- * - If the value is a State object, it will be converted to a derived ref using derivedRef
- * - Otherwise, the value will be kept as is
- *
- * @template T - The type of props extending Props
- * @param {T} props - The input props object containing KeyLike or State values
- * @returns {PropsRef<T>} A new object with State values converted to Refs
- */
-declare function propsRef<T extends Props>(props: T): PropsRef<T>;
-
-/**
- * Creates a Svelte readable store that observes a reactive function and updates its subscribers
- * when the observed value changes. The function automatically handles observer lifecycle
- * and cleanup using Svelte's onDestroy hook.
- *
- * @template R - The type of the observed value
- * @param observe - A function that returns the value to be observed
- * @returns A Svelte readable store containing the observed value
- */
-declare function observedRef<R>(observe: () => R): Readable<R>;
-
-declare const REF_REGISTRY: WeakMap<ConstantRef<unknown>, StateRef<unknown>>;
-/**
- * Creates a readable reference that can be subscribed to for reactive updates.
- * This function initializes a reactive reference with a given initial value and provides
- * mechanisms for subscribing to changes and publishing updates to subscribers.
- *
- * @template T The type of the value being referenced
- * @param init - The initial value for the reference
- * @param updater
- * @returns A readable reference object with subscribe and publish capabilities
- */
-declare function variableRef<T>(init: T, updater?: (value: T) => T): VariableRef<T>;
-/**
- * Creates a constant (read-only) reference that can be subscribed to for reactive updates.
- * This function initializes a reactive reference with a given initial value that cannot be modified
- * after creation.
- *
- * @template T The type of the value being referenced
- * @param init - The initial value for the reference
- * @param constant - If true, the reference will be read-only and cannot be updated.
- * @returns A constant reference object with subscribe capability but no write access
- */
-declare function variableRef<T>(init: T, constant: true): ConstantRef<T>;
-/**
- * Creates a constant (read-only) reference that can be subscribed to for reactive updates.
- * This function initializes a reactive reference with a given initial value that cannot be modified
- * after creation. It's useful for values that should remain constant throughout the component lifecycle
- * but still need to be reactively tracked.
- *
- * @template T The type of the value being referenced
- * @param init - The initial value for the constant reference
- * @returns A constant reference object with subscribe capability but no write access
- */
-declare function constantRef<T>(init: T): ConstantRef<T>;
-/**
- * Checks if a given value is a writable reference.
- * This function uses the REF_REGISTRY to determine if the provided value
- * is a registered writable reference.
- *
- * @template T The type of the value that the reference holds
- * @param ref - The value to check
- * @returns True if the value is a writable reference, false otherwise
- */
-declare function isRef<T>(ref: unknown): ref is VariableRef<T>;
-
-export { ConstantRef, type Props, type PropsRef, REF_REGISTRY, StateRef, VariableRef, anchorRef, constantRef, derivedRef, exceptionRef, fetchRef, flatRef, historyRef, immutableRef, isRef, modelRef, observedRef, orderedRef, propsRef, rawRef, streamRef, variableRef, writableRef };
+import { anchorRef, flatRef, orderedRef, rawRef, reactiveRef } from "./anchor.js";
+import { ConstantRef, StateRef, VariableRef } from "./types.js";
+import { derivedRef } from "./derive.js";
+import { fetchRef, streamRef } from "./fetch.js";
+import { historyRef } from "./history.js";
+import { immutableRef, writableRef } from "./immutable.js";
+import { exceptionRef, modelRef } from "./model.js";
+import { observedRef } from "./observable.js";
+import { Props, PropsRef, propsRef } from "./prop.js";
+import { REF_REGISTRY, constantRef, isRef, variableRef } from "./ref.js";
+import { AnchorSettings, BatchHandler, Context, ContextProvider, DerivedRef, EffectHandler, FetchOptions, FetchState, FetchStatus, HistoryOptions, HistoryState, Immutable, ImmutableOutput, ImmutableRef, MicroBatch, MicroLooper, MicroPusher, MicroTask, ModelError, ModelInput, ModelObject, Mutable, MutablePart, MutableRef, PushHandler, State, StateChange, StateException, StateExceptionHandler, StateObserver, StateOptions, StateSubscriber, StateUnsubscribe, TaskHandler, Writable, anchor, derived, effect, exception, fetchState, form, getContext, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, setContext, shortId, streamState, stringify, subscribe, undoable, writable } from "@anchorlib/core";
+export { type AnchorSettings, type BatchHandler, ConstantRef, type Context, type ContextProvider, DerivedRef, type EffectHandler, type FetchOptions, type FetchState, FetchStatus, type HistoryOptions, type HistoryState, type Immutable, type ImmutableOutput, ImmutableRef, type MicroBatch, type MicroLooper, type MicroPusher, type MicroTask, type ModelError, type ModelInput, type ModelObject, type Mutable, type MutablePart, MutableRef, Props, PropsRef, type PushHandler, REF_REGISTRY, type State, type StateChange, type StateException, type StateExceptionHandler, type StateObserver, type StateOptions, StateRef, type StateSubscriber, type StateUnsubscribe, type TaskHandler, VariableRef, type Writable, anchor, anchorRef, constantRef, derived, derivedRef, effect, exception, exceptionRef, fetchRef, fetchState, flatRef, form, getContext, history, historyRef, immutable, immutableRef, isImmutableRef, isMutableRef, isRef, isValueRef, microbatch, microloop, micropush, microtask, model, modelRef, mutable, observedRef, ordered, orderedRef, propsRef, rawRef, reactiveRef, setContext, shortId, streamRef, streamState, stringify, subscribe, undoable, variableRef, writable, writableRef };

package/dist/index.js

@@ -1,207 +1,13 @@
-import { anchor, derive, linkable, fetchState, streamState, history, captureStack, createObserver } from '@anchorlib/core';
-import { onDestroy } from 'svelte';
-import 'svelte/store';
+import { anchorRef, flatRef, orderedRef, rawRef, reactiveRef } from "./anchor.js";
+import { REF_REGISTRY, constantRef, isRef, variableRef } from "./ref.js";
+import { derivedRef } from "./derive.js";
+import { fetchRef, streamRef } from "./fetch.js";
+import { historyRef } from "./history.js";
+import { immutableRef, writableRef } from "./immutable.js";
+import "./reactive.js";
+import { exceptionRef, modelRef } from "./model.js";
+import { observedRef } from "./observable.js";
+import { propsRef } from "./prop.js";
+import { DerivedRef, FetchStatus, ImmutableRef, MutableRef, anchor, derived, effect, exception, fetchState, form, getContext, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, setContext, shortId, streamState, stringify, subscribe, undoable, writable } from "@anchorlib/core";
 
-// src/anchor.ts
-var REF_REGISTRY = /* @__PURE__ */ new WeakMap();
-function variableRef(init, constant) {
-  const subscribers = /* @__PURE__ */ new Set();
-  const stateRef = anchor({ value: init }, { recursive: true });
-  const controller = derive.resolve(stateRef);
-  let leaveState = void 0;
-  const set = (value) => {
-    if (constant === true || value === stateRef.value) return;
-    if (typeof constant === "function") {
-      stateRef.value = constant(value);
-      return;
-    }
-    if (!linkable(value)) {
-      stateRef.value = value;
-      return;
-    }
-    const { schema, configs } = anchor.has(stateRef.value) ? derive.resolve(stateRef.value)?.meta ?? {} : {};
-    stateRef.value = anchor(value, schema ?? configs, configs);
-  };
-  const subscribe = (handler) => {
-    if (!anchor.has(stateRef)) {
-      handler(stateRef.value);
-      return () => {
-      };
-    }
-    if (!leaveState) {
-      leaveState = controller.subscribe.all((_, event) => {
-        if (event.type !== "init" && !event.error) {
-          publish();
-        }
-      });
-    }
-    handler(stateRef.value);
-    subscribers.add(handler);
-    return () => {
-      subscribers.delete(handler);
-      if (!subscribers.size) {
-        leaveState?.();
-        leaveState = void 0;
-      }
-    };
-  };
-  const publish = () => {
-    for (const subscriber of subscribers) {
-      subscriber(stateRef.value);
-    }
-  };
-  onDestroy(() => {
-    subscribers.clear();
-    leaveState?.();
-    leaveState = void 0;
-    REF_REGISTRY.delete(ref);
-    anchor.destroy(stateRef);
-  });
-  const ref = {
-    get value() {
-      return stateRef.value;
-    },
-    set value(value) {
-      set(value);
-    }
-  };
-  Object.defineProperties(ref, {
-    publish: {
-      value: publish
-    },
-    subscribe: {
-      value: subscribe
-    },
-    set: {
-      value: set
-    }
-  });
-  REF_REGISTRY.set(ref, stateRef);
-  return ref;
-}
-function constantRef(init) {
-  return variableRef(init, true);
-}
-function isRef(ref) {
-  return REF_REGISTRY.has(ref);
-}
-
-// src/anchor.ts
-function anchorRef(init, schemaOptions, options) {
-  const state = linkable(init) ? anchor(init, schemaOptions, options) : init;
-  return variableRef(state);
-}
-function orderedRef(init, compare, options) {
-  const state = anchor.ordered(init, compare, options);
-  return variableRef(state);
-}
-function flatRef(init, options) {
-  const state = anchor.flat(init, options);
-  return variableRef(state);
-}
-function rawRef(init, options) {
-  const state = anchor.raw(init, options);
-  return variableRef(state);
-}
-function derivedRef(state, transformRecursive) {
-  let target = state;
-  if (isRef(state)) {
-    target = REF_REGISTRY.get(state);
-  }
-  const subscribe = (handler) => {
-    return derive(
-      target,
-      (current) => {
-        if (isRef(state)) {
-          current = state.value;
-        } else {
-          current = state;
-        }
-        const value = typeof transformRecursive === "function" ? transformRecursive(current) : current;
-        handler(value);
-      },
-      typeof transformRecursive === "boolean" ? transformRecursive : void 0
-    );
-  };
-  return { subscribe, set: () => {
-  } };
-}
-function fetchRef(init, options) {
-  const state = fetchState(init, options);
-  return constantRef(state);
-}
-function streamRef(init, options) {
-  const state = streamState(init, options);
-  return constantRef(state);
-}
-function historyRef(state, options) {
-  const historyState = history(state, options);
-  return constantRef(historyState);
-}
-function immutableRef(init, schemaOptions, options) {
-  const state = anchor.immutable(init, schemaOptions, options);
-  return variableRef(state);
-}
-function writableRef(state, contracts) {
-  const writableState = anchor.writable(state, contracts);
-  return variableRef(writableState);
-}
-function modelRef(schema, init, options) {
-  const state = anchor(init, schema, options);
-  return variableRef(state);
-}
-function exceptionRef(state) {
-  if (isRef(state)) {
-    state = REF_REGISTRY.get(state).value;
-    captureStack.violation.general(
-      "VariableRef passing detected:",
-      "Attempted to capture exception on a VariableRef.",
-      new Error("Unexpected VariableRef passing"),
-      [
-        `While it works, it won't update when the variable value itself changed.`,
-        `We always recommend passing the state directly instead of passing the VariableRef.`
-      ],
-      exceptionRef
-    );
-  }
-  const exception = anchor.catch(state);
-  return constantRef(exception);
-}
-function propsRef(props) {
-  const ref = {};
-  for (const [key, value] of Object.entries(props)) {
-    if (anchor.has(value)) {
-      ref[key] = constantRef(value);
-    } else {
-      ref[key] = value;
-    }
-  }
-  return ref;
-}
-function observedRef(observe) {
-  const subscribers = /* @__PURE__ */ new Set();
-  const observer = createObserver(() => {
-    update();
-  });
-  let current = observer.run(observe);
-  const update = () => {
-    current = observer.run(observe);
-    subscribers.forEach((handler) => handler(current));
-  };
-  const subscribe = (handler) => {
-    handler(current);
-    subscribers.add(handler);
-    return () => {
-      subscribers.delete(handler);
-    };
-  };
-  onDestroy(() => {
-    observer.destroy();
-  });
-  return { subscribe, set: () => {
-  } };
-}
-
-export { REF_REGISTRY, anchorRef, constantRef, derivedRef, exceptionRef, fetchRef, flatRef, historyRef, immutableRef, isRef, modelRef, observedRef, orderedRef, propsRef, rawRef, streamRef, variableRef, writableRef };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { DerivedRef, FetchStatus, ImmutableRef, MutableRef, REF_REGISTRY, anchor, anchorRef, constantRef, derived, derivedRef, effect, exception, exceptionRef, fetchRef, fetchState, flatRef, form, getContext, history, historyRef, immutable, immutableRef, isImmutableRef, isMutableRef, isRef, isValueRef, microbatch, microloop, micropush, microtask, model, modelRef, mutable, observedRef, ordered, orderedRef, propsRef, rawRef, reactiveRef, setContext, shortId, streamRef, streamState, stringify, subscribe, undoable, variableRef, writable, writableRef };

package/dist/model.d.ts

@@ -0,0 +1,41 @@
+import { ImmutableOutput, LinkableSchema, ModelInput, ModelOutput, ObjLike, StateBaseOptions, StateExceptionMap } from "@anchorlib/core";
+
+//#region src/model.d.ts
+
+/**
+ * @deprecated Use 'model()' instead.
+ * Creates a model with mutable state.
+ *
+ * @template S - The linkable schema type
+ * @template T - The model input type that extends the schema
+ * @param schema - The schema to use for the model
+ * @param init - The initial value for the model
+ * @param options - Optional state configuration
+ * @returns A model output.
+ */
+declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options?: StateBaseOptions): ModelOutput<S>;
+/**
+ * @deprecated Use 'model()' instead.
+ * Creates a model with immutable state.
+ *
+ * @template S - The linkable schema type
+ * @template T - The model input type that extends the schema
+ * @param schema - The schema to use for the model
+ * @param init - The initial value for the model
+ * @param options - State configuration with immutable flag set to true
+ * @returns An immutable model output.
+ */
+declare function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(schema: S, init: T, options: StateBaseOptions & {
+  immutable: true;
+}): ImmutableOutput<S>;
+/**
+ * @deprecated Use 'exception()' instead.
+ * Creates a state that maps exceptions for a given state object or array.
+ *
+ * @template T - The type of the input state, must be an object-like or array type
+ * @param state - The input state object or array to create exception mappings for
+ * @returns A StateExceptionMap for the provided state.
+ */
+declare function exceptionRef<T extends ObjLike | Array<unknown>>(state: T): StateExceptionMap<T>;
+//#endregion
+export { exceptionRef, modelRef };

package/dist/model.js

@@ -0,0 +1,20 @@
+import { anchor } from "@anchorlib/core";
+
+//#region src/model.ts
+function modelRef(schema, init, options) {
+	return anchor(init, schema, options);
+}
+/**
+* @deprecated Use 'exception()' instead.
+* Creates a state that maps exceptions for a given state object or array.
+*
+* @template T - The type of the input state, must be an object-like or array type
+* @param state - The input state object or array to create exception mappings for
+* @returns A StateExceptionMap for the provided state.
+*/
+function exceptionRef(state) {
+	return anchor.catch(state);
+}
+
+//#endregion
+export { exceptionRef, modelRef };

package/dist/observable.d.ts

@@ -0,0 +1,17 @@
+import { ConstantRef } from "./types.js";
+
+//#region src/observable.d.ts
+
+/**
+ * @deprecated use `effect()` instead.
+ * Creates a read-only reference that observes a reactive function and updates its value
+ * when the observed value changes. The function automatically handles observer lifecycle
+ * and cleanup using Svelte's onDestroy hook.
+ *
+ * @template R - The type of the observed value
+ * @param observe - A function that returns the value to be observed
+ * @returns A read-only reference containing the observed value
+ */
+declare function observedRef<R>(observe: () => R): ConstantRef<R>;
+//#endregion
+export { observedRef };

package/dist/observable.js

@@ -0,0 +1,36 @@
+import { REF_REGISTRY } from "./ref.js";
+import { anchor, createObserver } from "@anchorlib/core";
+import { onDestroy } from "svelte";
+
+//#region src/observable.ts
+/**
+* @deprecated use `effect()` instead.
+* Creates a read-only reference that observes a reactive function and updates its value
+* when the observed value changes. The function automatically handles observer lifecycle
+* and cleanup using Svelte's onDestroy hook.
+*
+* @template R - The type of the observed value
+* @param observe - A function that returns the value to be observed
+* @returns A read-only reference containing the observed value
+*/
+function observedRef(observe) {
+	const observer = createObserver(() => {
+		update();
+	});
+	const valueRef = anchor({ value: observer.run(observe) }, { recursive: false });
+	const stateRef = { get value() {
+		return valueRef.value;
+	} };
+	REF_REGISTRY.set(stateRef, valueRef);
+	const update = () => {
+		valueRef.value = observer.run(observe);
+	};
+	onDestroy(() => {
+		observer.destroy();
+		REF_REGISTRY.delete(stateRef);
+	});
+	return stateRef;
+}
+
+//#endregion
+export { observedRef };

package/dist/prop.d.ts

@@ -0,0 +1,21 @@
+import { ConstantRef } from "./types.js";
+import { KeyLike, State } from "@anchorlib/core";
+
+//#region src/prop.d.ts
+type Props = {
+  [key: string]: KeyLike | State;
+};
+type PropsRef<T extends Props> = { [K in keyof T]: T[K] extends State ? ConstantRef<T[K]> : T[K] };
+/**
+ * Creates a reactive state object from the provided props.
+ * For each property in the input props:
+ * - If the value is a State object, it will be converted to a derived state
+ * - Otherwise, the value will be kept as is
+ * @deprecated
+ * @template T - The type of props extending Props
+ * @param {T} props - The input props object containing KeyLike or State values
+ * @returns {PropsRef<T>} A new object with State values converted to reactive states
+ */
+declare function propsRef<T extends Props>(props: T): T;
+//#endregion
+export { Props, PropsRef, propsRef };