@anchorlib/svelte 1.0.0-beta.9 → 1.0.0

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+import { KeyLike, Linkable } from "@anchorlib/core";
+
+//#region src/client/index.d.ts
+declare const TRACKER_REGISTRY: WeakMap<Linkable, (prop: KeyLike) => void>;
+//#endregion
+export { TRACKER_REGISTRY };

package/dist/client/index.js

@@ -0,0 +1,52 @@
+import { anchor, createObserver, isBrowser, onGlobalCleanup, setCleanUpHandler, setTracker } from "@anchorlib/core";
+import { onDestroy } from "svelte";
+import { createSubscriber } from "svelte/reactivity";
+
+//#region src/client/index.ts
+anchor.configure({ globalScopeWarning: false });
+const TRACKER_REGISTRY = /* @__PURE__ */ new WeakMap();
+let bindingInitialized = false;
+if (!bindingInitialized && isBrowser()) {
+	bindingInitialized = true;
+	/**
+	* Sets up a tracker function that integrates Anchor's reactivity system with Svelte's reactivity.
+	* This tracker is responsible for creating observers that watch for changes in reactive objects
+	* and properly subscribing/unsubscribing to Svelte's reactivity system.
+	*
+	* @param init - The initial linkable object to track
+	* @param observers - The observers collection to use for tracking
+	* @param key - The specific key/property to track on the object
+	*/
+	setTracker((init, observers, key) => {
+		if (!TRACKER_REGISTRY.has(init)) {
+			let track;
+			const subscribe = createSubscriber((update) => {
+				const observer = createObserver(() => {
+					observer.reset();
+					update();
+				}, void 0, true);
+				track = observer.assign(init, observers);
+				return () => {
+					observer.destroy();
+					TRACKER_REGISTRY.delete(init);
+				};
+			});
+			const assign = (prop) => {
+				subscribe();
+				track?.(prop);
+			};
+			TRACKER_REGISTRY.set(init, assign);
+		}
+		TRACKER_REGISTRY.get(init)?.(key);
+	});
+	setCleanUpHandler((handler) => {
+		try {
+			return onDestroy(handler);
+		} catch (_error) {
+			return onGlobalCleanup(handler);
+		}
+	});
+}
+
+//#endregion
+export { TRACKER_REGISTRY };

package/dist/core/index.d.ts

@@ -0,0 +1 @@
+export * from "@anchorlib/core";

package/dist/core/index.js

@@ -0,0 +1 @@
+export * from "@anchorlib/core"

package/dist/index.d.ts

@@ -1,307 +1,3 @@
-import { Linkable, LinkableSchema, StateOptions, ModelInput, ModelOutput, Immutable, ModelArray, 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 extends Linkable, 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>>>;
-/**
- * Reactive reference alias for anchorRef.
- * @type {{<T, S=LinkableSchema extends LinkableSchema>(init: T, options?: StateOptions<S>): VariableRef<T>, <S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions): VariableRef<ModelOutput<S>>, <S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: (StateOptions & {immutable: true})): VariableRef<Immutable<ModelOutput<S>>>}}
- */
-declare const reactiveRef: typeof anchorRef;
-/**
- * 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
- * @returns A readable store containing the state value
- */
-declare function derivedRef<T>(state: T | VariableRef<T>): 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
- * @returns A readable reference object with subscribe and publish capabilities
- */
-declare function variableRef<T>(init: 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, reactiveRef, streamRef, variableRef, writableRef };
+import { ASYNC_STATUS, AnchorSettings, AsyncHandler, AsyncOptions, AsyncState, BatchHandler, CookieEntry, CookieJar, CookieOptions, Debouncer, DerivedRef, EffectHandler, FetchOptions, FetchState, FetchStatus, Future, 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, awaited, cookies, createContext, createLifecycle, debouncer, decodeCookies, derived, effect, encodeCookies, exception, fetchState, form, getContext, getCookieJar, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, query, setContext, setCookieContext, setReactive, shortId, snapshot, streamState, stringify, subscribe, undoable, untrack, withIsolation, withScope, writable } from "@anchorlib/core";
+import { WORKFLOW_STATUS, WORKFLOW_STORE, plan } from "@anchorlib/core/workflow";
+export { ASYNC_STATUS, type AnchorSettings, type AsyncHandler, type AsyncOptions, type AsyncState, type BatchHandler, type CookieEntry, CookieJar, type CookieOptions, type Debouncer, DerivedRef, type EffectHandler, type FetchOptions, type FetchState, FetchStatus, type Future, 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, type PushHandler, type State, type StateChange, type StateException, type StateExceptionHandler, type StateObserver, type StateOptions, type StateSubscriber, type StateUnsubscribe, type TaskHandler, WORKFLOW_STATUS, WORKFLOW_STORE, type Writable, anchor, awaited, cookies, createContext, createLifecycle, debouncer, decodeCookies, derived, effect, encodeCookies, exception, fetchState, form, getContext, getCookieJar, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, plan, query, setContext, setCookieContext, setReactive, shortId, snapshot, streamState, stringify, subscribe, undoable, untrack, withIsolation, withScope, writable };

package/dist/index.js

@@ -1,190 +1,5 @@
-import { anchor, subscribe, fetchState, streamState, history, captureStack, createObserver } from '@anchorlib/core';
-import { onDestroy } from 'svelte';
-import 'svelte/store';
+import "./client/index.js";
+import { ASYNC_STATUS, CookieJar, DerivedRef, FetchStatus, ImmutableRef, MutableRef, anchor, awaited, cookies, createContext, createLifecycle, debouncer, decodeCookies, derived, effect, encodeCookies, exception, fetchState, form, getContext, getCookieJar, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, query, setContext, setCookieContext, setReactive, shortId, snapshot, streamState, stringify, subscribe, undoable, untrack, withIsolation, withScope, writable } from "@anchorlib/core";
+import { WORKFLOW_STATUS, WORKFLOW_STORE, plan } from "@anchorlib/core/workflow";
 
-// 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 = subscribe.resolve(stateRef);
-  let leaveState = void 0;
-  const set = (value) => {
-    if (constant === true || value === stateRef.value) return;
-    stateRef.value = value;
-  };
-  const subscribe$1 = (handler) => {
-    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$1
-    },
-    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 = anchor(init, schemaOptions, options);
-  return variableRef(state);
-}
-var reactiveRef = anchorRef;
-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, transform) {
-  let target = state;
-  if (isRef(state)) {
-    target = REF_REGISTRY.get(state);
-  }
-  const subscribe$1 = (handler) => {
-    return subscribe(target, (current) => {
-      if (isRef(state)) {
-        current = state.value;
-      } else {
-        current = state;
-      }
-      const value = typeof transform === "function" ? transform(current) : current;
-      handler(value);
-    });
-  };
-  return { subscribe: subscribe$1, 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, reactiveRef, streamRef, variableRef, writableRef };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export { ASYNC_STATUS, CookieJar, DerivedRef, FetchStatus, ImmutableRef, MutableRef, WORKFLOW_STATUS, WORKFLOW_STORE, anchor, awaited, cookies, createContext, createLifecycle, debouncer, decodeCookies, derived, effect, encodeCookies, exception, fetchState, form, getContext, getCookieJar, history, immutable, isImmutableRef, isMutableRef, isValueRef, microbatch, microloop, micropush, microtask, model, mutable, ordered, plan, query, setContext, setCookieContext, setReactive, shortId, snapshot, streamState, stringify, subscribe, undoable, untrack, withIsolation, withScope, writable };

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/server/index.js

@@ -0,0 +1,14 @@
+import { isBrowser, setAsyncScope, setReactive } from "@anchorlib/core";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/server/index.ts
+var AnchorASL = class extends AsyncLocalStorage {
+	store = /* @__PURE__ */ new Map();
+	getStore() {
+		return super.getStore() ?? this.store;
+	}
+};
+setAsyncScope(new AnchorASL());
+if (!isBrowser()) setReactive(false);
+
+//#endregion

package/dist/storage/index.d.ts

@@ -1,61 +1,2 @@
-import { Storable, KVState, Rec, Row, RowState, FilterFn, RowListState, ReactiveTable, InferRec } from '@anchorlib/storage/db';
-import { C as ConstantRef } from '../types-CsfltB4A.js';
-import { ObjLike, LinkableSchema, StateOptions } from '@anchorlib/core';
-
-/**
- * Creates a reactive reference to a key-value store state.
- *
- * This function initializes a key-value store with the given name and initial value,
- * and automatically cleans up the store subscription when the component is destroyed.
- *
- * @template T - The type of the stored value, must extend Storable
- * @param name - The unique identifier for the key-value store
- * @param init - The initial value for the store
- * @returns A reactive reference to the key-value store state
- */
-declare function kvRef<T extends Storable>(name: string, init: T): ConstantRef<KVState<T>>;
-
-/**
- * Creates a persistent reactive reference using the provided name, initial value, and options.
- * The persistentRef is tied to the browser's local storage, meaning its value will persist
- * across page reloads and browser sessions until explicitly cleared.
- *
- * @template T - The type of the initial value, must extend object-like structure.
- * @template S - The schema type for linkable validation, defaults to LinkableSchema.
- * @param name - A unique string identifier for the local storage key.
- * @param init - The initial value to be stored in local storage.
- * @param options - Optional configuration for state behavior and validation schema.
- * @returns A WritableRef<T> that provides reactive access and modification capabilities.
- */
-declare function persistentRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(name: string, init: T, options?: StateOptions<S>): ConstantRef<T>;
-
-/**
- * Creates a session-scoped reactive reference using the provided name, initial value, and options.
- * The sessionRef is tied to the browser's session storage, meaning its value will persist
- * across page reloads but not after the session ends (e.g., tab/window closed).
- *
- * @template T - The type of the initial value, must extend object-like structure.
- * @template S - The schema type for linkable validation, defaults to LinkableSchema.
- * @param name - A unique string identifier for the session storage key.
- * @param init - The initial value to be stored in session storage.
- * @param options - Optional configuration for state behavior and validation schema.
- * @returns A WritableRef<T> that provides reactive access and modification capabilities.
- */
-declare function sessionRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(name: string, init: T, options?: StateOptions<S>): ConstantRef<T>;
-
-interface TableRef<T extends Rec, R extends Row<T> = Row<T>> {
-    get(id: string): ConstantRef<RowState<R>>;
-    add(payload: T): ConstantRef<RowState<R>>;
-    remove(id: string): ConstantRef<RowState<R>>;
-    list(filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection): ConstantRef<RowListState<R>>;
-    listByIndex(name: keyof R, filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection): ConstantRef<RowListState<R>>;
-    seed<T extends R[]>(seeds: T): this;
-    table(): ReactiveTable<T>;
-}
-type InferRef<T> = T extends TableRef<Rec, infer R> ? ConstantRef<R> : never;
-type InferListRef<T> = T extends TableRef<Rec, infer R> ? ConstantRef<R[]> : never;
-
-declare function createTableRef<T extends ReactiveTable<Rec>>(table: T): TableRef<InferRec<T>>;
-declare function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(name: string, version?: number, indexes?: (keyof R)[], remIndexes?: (keyof R)[], dbName?: string): TableRef<T, R>;
-
-export { type InferListRef, type InferRef, type TableRef, createTableRef, kvRef, persistentRef, sessionRef };
+export * from "@anchorlib/storage";
+export * from "@anchorlib/storage/db";

package/dist/storage/index.js

@@ -1,66 +1,3 @@
-import { kv, createTable } from '@anchorlib/storage/db';
-import { constantRef } from '../index.js';
-import { onDestroy } from 'svelte';
-import { persistent, session } from '@anchorlib/storage';
+export * from "@anchorlib/storage"
 
-// src/storage/kv.ts
-function kvRef(name, init) {
-  const state = kv(name, init);
-  onDestroy(() => {
-    kv.leave(state);
-  });
-  return constantRef(state);
-}
-function persistentRef(name, init, options) {
-  const state = persistent(name, init, options);
-  return constantRef(state);
-}
-function sessionRef(name, init, options) {
-  const state = session(name, init, options);
-  return constantRef(state);
-}
-function createTableRef(tableName, version = 1, indexes, remIndexes, dbName = tableName) {
-  if (typeof tableName === "string") {
-    tableName = createTable(tableName, version, indexes, remIndexes, dbName);
-  }
-  const tableRef = tableName;
-  return {
-    get(id) {
-      const state = tableRef.get(id);
-      onDestroy(() => {
-        tableRef.leave(id);
-      });
-      return constantRef(state);
-    },
-    add(payload) {
-      const state = tableRef.add(payload);
-      onDestroy(() => {
-        tableRef.leave(state.data.id);
-      });
-      return constantRef(state);
-    },
-    list(filter, limit, direction) {
-      const state = tableRef.list(filter, limit, direction);
-      return constantRef(state);
-    },
-    listByIndex(name, filter, limit, direction) {
-      const state = tableRef.listByIndex(name, filter, limit, direction);
-      return constantRef(state);
-    },
-    remove(id) {
-      const state = tableRef.remove(id);
-      return constantRef(state);
-    },
-    seed(seeds) {
-      tableRef.seed(seeds);
-      return this;
-    },
-    table() {
-      return tableRef;
-    }
-  };
-}
-
-export { createTableRef, kvRef, persistentRef, sessionRef };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+export * from "@anchorlib/storage/db"

package/dist/workflow/index.d.ts

@@ -0,0 +1 @@
+export * from "@anchorlib/core/workflow";

package/dist/workflow/index.js

@@ -0,0 +1 @@
+export * from "@anchorlib/core/workflow"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchorlib/svelte",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0",
   "description": "Svelte bindings for Anchor reactive state management",
   "keywords": [
     "state",
@@ -10,14 +10,14 @@
     "svelte"
   ],
   "author": "Nanang Mahdaen El Agung <mahdaen@gmail.com>",
-  "homepage": "https://github.com/beerush-id/anchor",
+  "homepage": "https://github.com/beerush-id/airstack",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/beerush-id/anchor.git"
+    "url": "git+https://github.com/beerush-id/airstack.git"
   },
   "bugs": {
-    "url": "https://github.com/beerush-id/anchor/issues"
+    "url": "https://github.com/beerush-id/airstack/issues"
   },
   "type": "module",
   "module": "./dist/index.js",
@@ -29,10 +29,29 @@
       "svelte": "./dist/index.js",
       "import": "./dist/index.js"
     },
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "svelte": "./dist/client/index.js",
+      "import": "./dist/client/index.js"
+    },
+    "./reactive": {
+      "types": "./dist/client/index.d.ts",
+      "svelte": "./dist/client/index.js",
+      "import": "./dist/client/index.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "svelte": "./dist/core/index.js",
+      "import": "./dist/core/index.js"
+    },
     "./storage": {
       "types": "./dist/storage/index.d.ts",
       "svelte": "./dist/storage/index.js",
       "import": "./dist/storage/index.js"
+    },
+    "./workflow": {
+      "types": "./dist/workflow/index.d.ts",
+      "import": "./dist/workflow/index.js"
     }
   },
   "directories": {
@@ -45,38 +64,35 @@
     "access": "public"
   },
   "dependencies": {
-    "@anchorlib/core": "^1.0.0-beta.9",
-    "@anchorlib/storage": "^1.0.0-beta.9"
+    "@anchorlib/core": "^1.0.0",
+    "@anchorlib/storage": "^1.0.0"
   },
   "devDependencies": {
-    "@eslint/css": "^0.5.0",
-    "@eslint/js": "^9.23.0",
-    "@eslint/markdown": "^6.3.0",
-    "@sveltejs/vite-plugin-svelte": "^6.2.1",
-    "@testing-library/svelte": "^5.2.8",
-    "@testing-library/user-event": "^14.6.1",
-    "@types/react": "^19.1.8",
+    "@biomejs/biome": "2.3.3",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@testing-library/svelte": "5.2.8",
+    "@testing-library/user-event": "14.6.1",
+    "@types/bun": "1.3.1",
+    "@types/react": "^19.1.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
-    "eslint": "^9.23.0",
-    "eslint-plugin-prettier": "^5.2.3",
-    "jsdom": "^27.0.0",
-    "prettier": "^3.5.3",
-    "publint": "^0.3.9",
-    "rimraf": "^6.0.1",
-    "tsup": "^8.4.0",
-    "typescript-eslint": "^8.27.0",
+    "jsdom": "27.0.1",
+    "publint": "0.3.15",
+    "rimraf": "6.0.1",
+    "tsdown": "0.15.9",
+    "vite": "8.0.10",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "svelte": "^5.36.16",
-    "typescript": "^5.8.2"
+    "svelte": "^5.0.0",
+    "typescript": "^5.9.3"
   },
   "scripts": {
-    "dev": "rimraf dist && tsup --watch",
+    "dev": "rimraf dist && tsdown --watch ./src",
     "clean": "rimraf dist",
-    "build": "rimraf dist && tsup && publint",
-    "prepublish": "rimraf dist && tsup && publint",
-    "format": "prettier --write .",
+    "build": "rimraf dist && tsdown && publint",
+    "prepublish": "rimraf dist && tsdown && publint",
+    "format": "biome format --write",
     "test": "rimraf coverage && vitest --run",
     "test:preview": "rimraf coverage && vitest --run && vite preview --outDir coverage"
   },

package/readme.md

@@ -1,15 +1,6 @@
-# @anchorlib/svelte
+# Anchor Svelte Library
 
-Svelte integration for the Anchor reactive state management library.
-
-## Features
-
-- **Reactive State Management** - Directly mutate state without needing setState patterns
-- **Automatic Cleanup** - Automatic subscription cleanup using Svelte's onDestroy lifecycle
-- **Svelte 5 Runes Integration** - Works with Svelte 5's runes system
-- **Framework Optimized** - Designed specifically for Svelte's reactivity model
-- **Schema Validation** - Built-in Zod schema validation support
-- **Type Safety** - Full TypeScript support with comprehensive type definitions
+This is the official Anchor library for Svelte. It provides a set of tools to manage state in your Svelte applications, based on the principles of the Anchor framework.
 
 ## Installation
 
@@ -19,7 +10,7 @@ npm install @anchorlib/svelte
 
 ## Documentation
 
-For full documentation, visit [Anchor for Svelte](https://anchorlib.dev/docs/svelte/introduction.html)
+For full documentation, visit [Anchor for Svelte](https://airlib.dev/svelte/introduction.html)
 
 ## Quick Start
 
@@ -38,10 +29,10 @@ For full documentation, visit [Anchor for Svelte](https://anchorlib.dev/docs/sve
 </script>
 
 <div>
-  <h1>Hello {$state.user.name}</h1>
-  <p>Count: {$state.count}</p>
-  <button onclick={() => $state.count++}>Increment</button>
-  <button onclick={() => $state.user.name = 'Jane Doe'}>Change Name</button>
+  <h1>Hello {state.user.name}</h1>
+  <p>Count: {state.count}</p>
+  <button onclick={() => state.count++}>Increment</button>
+  <button onclick={() => state.user.name = 'Jane Doe'}>Change Name</button>
 </div>
 ```
 

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/ref.ts","../src/anchor.ts","../src/derive.ts","../src/fetch.ts","../src/history.ts","../src/immutable.ts","../src/model.ts","../src/prop.ts","../src/observable.ts"],"names":["derive","subscribe","anchor","onDestroy"],"mappings":"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","file":"index.js","sourcesContent":["import type { ConstantRef, RefSubscriber, StateRef, VariableRef } from './types.js';\nimport { anchor, type StateController, subscribe as derive } from '@anchorlib/core';\nimport { onDestroy } from 'svelte';\n\nexport const REF_REGISTRY = new WeakMap<ConstantRef<unknown>, StateRef<unknown>>();\n\n/**\n * Creates a readable reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value and provides\n * mechanisms for subscribing to changes and publishing updates to subscribers.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the reference\n * @returns A readable reference object with subscribe and publish capabilities\n */\nexport function variableRef<T>(init: T): VariableRef<T>;\n\n/**\n * Creates a constant (read-only) reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value that cannot be modified\n * after creation.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the reference\n * @param constant - If true, the reference will be read-only and cannot be updated.\n * @returns A constant reference object with subscribe capability but no write access\n */\nexport function variableRef<T>(init: T, constant: true): ConstantRef<T>;\n\n/**\n * Creates a readable reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value and provides\n * mechanisms for subscribing to changes and publishing updates to subscribers.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the reference\n * @param constant - If true, the reference will be read-only and cannot be updated.\n * @returns A readable reference object with subscribe and publish capabilities\n */\nexport function variableRef<T>(init: T, constant?: boolean) {\n  const subscribers = new Set<RefSubscriber<T>>();\n  const stateRef = anchor({ value: init }, { recursive: true });\n  const controller = derive.resolve(stateRef) as StateController;\n\n  let leaveState: ((destroy?: boolean) => void) | undefined = undefined;\n\n  const set = (value: T) => {\n    // Ignore if the value is the same.\n    if (constant === true || value === stateRef.value) return;\n\n    stateRef.value = value;\n  };\n\n  const subscribe = (handler: RefSubscriber<T>) => {\n    if (!leaveState) {\n      leaveState = controller.subscribe.all((_, event) => {\n        if (event.type !== 'init' && !event.error) {\n          publish();\n        }\n      });\n    }\n\n    handler(stateRef.value);\n    subscribers.add(handler);\n\n    return () => {\n      subscribers.delete(handler);\n\n      if (!subscribers.size) {\n        leaveState?.();\n        leaveState = undefined;\n      }\n    };\n  };\n\n  const publish = () => {\n    for (const subscriber of subscribers) {\n      subscriber(stateRef.value);\n    }\n  };\n\n  onDestroy(() => {\n    // Clear the subscribers.\n    subscribers.clear();\n    // Leave the ref state.\n    leaveState?.();\n    leaveState = undefined;\n\n    // Remove the ref from the registry.\n    REF_REGISTRY.delete(ref as ConstantRef<unknown>);\n\n    // Destroy the ref state.\n    anchor.destroy(stateRef);\n  });\n\n  const ref = {\n    get value() {\n      return stateRef.value;\n    },\n    set value(value: T) {\n      set(value);\n    },\n  } as never;\n\n  Object.defineProperties(ref, {\n    publish: {\n      value: publish,\n    },\n    subscribe: {\n      value: subscribe,\n    },\n    set: {\n      value: set,\n    },\n  });\n\n  REF_REGISTRY.set(ref as ConstantRef<unknown>, stateRef);\n\n  return ref as ConstantRef<T>;\n}\n\n/**\n * Creates a constant (read-only) reference that can be subscribed to for reactive updates.\n * This function initializes a reactive reference with a given initial value that cannot be modified\n * after creation. It's useful for values that should remain constant throughout the component lifecycle\n * but still need to be reactively tracked.\n *\n * @template T The type of the value being referenced\n * @param init - The initial value for the constant reference\n * @returns A constant reference object with subscribe capability but no write access\n */\nexport function constantRef<T>(init: T): ConstantRef<T> {\n  return variableRef(init, true);\n}\n\n/**\n * Checks if a given value is a writable reference.\n * This function uses the REF_REGISTRY to determine if the provided value\n * is a registered writable reference.\n *\n * @template T The type of the value that the reference holds\n * @param ref - The value to check\n * @returns True if the value is a writable reference, false otherwise\n */\nexport function isRef<T>(ref: unknown): ref is VariableRef<T> {\n  return REF_REGISTRY.has(ref as VariableRef<unknown>);\n}\n","import {\n  anchor,\n  type Immutable,\n  type Linkable,\n  type LinkableSchema,\n  type ModelArray,\n  type ModelInput,\n  type ModelOutput,\n  type StateOptions,\n} from '@anchorlib/core';\nimport type { VariableRef } from './types.js';\nimport { variableRef } from './ref.js';\n\n/**\n * Creates a writable reference that can be used to manage state with Anchor.\n * This overload is used when no schema is provided, or when using a LinkableSchema with StateOptions.\n *\n * @template T - The type of the initial value\n * @template S - The schema type, extending LinkableSchema\n * @param init - The initial value for the reference\n * @param options - Optional state options for the reference\n * @returns A WritableRef containing the initial value\n */\nexport function anchorRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  options?: StateOptions<S>\n): VariableRef<T>;\n\n/**\n * Creates a writable reference with a defined schema for validation and type inference.\n *\n * @template S - The schema type, extending LinkableSchema\n * @template T - The type of the initial value, must extend ModelInput of the schema\n * @param init - The initial value for the reference\n * @param schema - The schema to validate and type the reference\n * @param options - Optional state options for the reference\n * @returns A WritableRef containing the output model based on the schema\n */\nexport function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  init: T,\n  schema?: S,\n  options?: StateOptions\n): VariableRef<ModelOutput<S>>;\n\n/**\n * Creates an immutable writable reference with a defined schema.\n *\n * @template S - The schema type, extending LinkableSchema\n * @template T - The type of the initial value, must extend ModelInput of the schema\n * @param init - The initial value for the reference\n * @param schema - The schema to validate and type the reference\n * @param options - State options with immutable flag set to true\n * @returns A WritableRef containing an immutable output model based on the schema\n */\nexport function anchorRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  init: T,\n  schema?: S,\n  options?: StateOptions & { immutable: true }\n): VariableRef<Immutable<ModelOutput<S>>>;\n\n/**\n * Creates a writable reference for state management with optional schema validation.\n *\n * @template T - The type of the initial value\n * @template S - The schema type or options\n * @param init - The initial value for the reference\n * @param schemaOptions - Either a schema or state options\n * @param options - Additional state options when schema is provided\n * @returns A WritableRef containing the managed state\n */\nexport function anchorRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  schemaOptions?: S | StateOptions,\n  options?: StateOptions\n): VariableRef<T | ModelOutput<S> | Immutable<ModelOutput<S>>> {\n  const state = anchor<S, ModelInput<S>>(init as ModelInput<S>, schemaOptions as S, options);\n  return variableRef(state);\n}\n\n/**\n * Reactive reference alias for anchorRef.\n * @type {{<T, S=LinkableSchema extends LinkableSchema>(init: T, options?: StateOptions<S>): VariableRef<T>, <S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: StateOptions): VariableRef<ModelOutput<S>>, <S extends LinkableSchema, T extends ModelInput<S>>(init: T, schema?: S, options?: (StateOptions & {immutable: true})): VariableRef<Immutable<ModelOutput<S>>>}}\n */\nexport const reactiveRef = anchorRef;\n\n/**\n * Creates a writable reference that maintains a sorted array state based on a comparison function.\n *\n * @template T - The type of elements in the array\n * @template S - The schema type for array elements, extending ModelArray\n * @param init - The initial array value for the reference\n * @param compare - A function that defines the sort order of elements\n * @param options - Optional state options for the reference\n * @returns A VariableRef containing the sorted array\n */\nexport function orderedRef<T extends unknown[], S extends ModelArray = ModelArray>(\n  init: T,\n  compare: (a: T[number], b: T[number]) => number,\n  options?: StateOptions<S>\n): VariableRef<T> {\n  const state = anchor.ordered(init, compare, options);\n  return variableRef(state);\n}\n\n/**\n * Creates a writable reference that maintains a flat array state.\n *\n * @template T - The type of elements in the array\n * @template S - The schema type for array elements, extending ModelArray\n * @param init - The initial array value for the reference\n * @param options - Optional state options for the reference\n * @returns A VariableRef containing the flat array\n */\nexport function flatRef<T extends unknown[], S extends ModelArray = ModelArray>(\n  init: T,\n  options?: StateOptions<S>\n): VariableRef<T> {\n  const state = anchor.flat(init, options);\n  return variableRef(state);\n}\n\n/**\n * Creates a writable reference that mutates the underlying object.\n *\n * Unless you set the global options to `cloned: true`, you don't want to use this.\n *\n * @template T - The type of the initial value\n * @template S - The schema type, extending LinkableSchema\n * @param init - The initial value for the reference\n * @param options - Optional state options for the reference\n * @returns A VariableRef containing the raw value\n */\nexport function rawRef<T extends Linkable, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  options?: StateOptions<S>\n): VariableRef<T> {\n  const state = anchor.raw(init, options);\n  return variableRef(state);\n}\n","import { subscribe as derive } from '@anchorlib/core';\nimport type { Readable } from 'svelte/store';\nimport type { StateRef, VariableRef } from './types.js';\nimport { isRef, REF_REGISTRY } from './ref.js';\n\n/**\n * Creates a derived store from a state or a writable reference.\n *\n * @template T - The type of the input state\n * @template R - The type of the transformed output\n * @param state - The input state or writable reference\n * @returns A readable store containing the state value\n */\nexport function derivedRef<T>(state: T | VariableRef<T>): Readable<T>;\n\n/**\n * Creates a derived store from a state or a writable reference with transformation.\n *\n * @template T - The type of the input state\n * @template R - The type of the transformed output\n * @param state - The input state or writable reference\n * @param transform - A function that transforms the current state value\n * @returns A readable store containing the transformed value\n */\nexport function derivedRef<T, R>(state: T | VariableRef<T>, transform: (current: T) => R): Readable<R>;\n\n/**\n * Creates a derived store from a state or a writable reference with optional transformation.\n *\n * @template T - The type of the input state\n * @template R - The type of the transformed output\n * @param state - The input state or writable reference\n * @param transform - An optional function that transforms the current state value\n * @returns A readable store containing the state value or transformed value\n */\nexport function derivedRef<T, R>(state: T | VariableRef<T>, transform?: (current: T) => R): Readable<T | R> {\n  let target = state;\n\n  if (isRef(state)) {\n    target = REF_REGISTRY.get(state as VariableRef<unknown>) as T;\n  }\n\n  const subscribe = (handler: (output: T | R) => void) => {\n    return derive(target, (current) => {\n      if (isRef(state)) {\n        current = (state as StateRef<T>).value;\n      } else {\n        current = state;\n      }\n\n      const value = typeof transform === 'function' ? transform(current as T) : current;\n      handler(value as T);\n    });\n  };\n\n  return { subscribe, set: () => {} } as Readable<T | R>;\n}\n","import { type FetchOptions, fetchState, type FetchState, type StreamOptions, streamState } from '@anchorlib/core';\nimport type { ConstantRef } from './types.js';\nimport { constantRef } from './ref.js';\n\n/**\n * Creates a readable Svelte store that manages the state of a fetch request.\n * This overload is for GET or DELETE requests, which typically do not have a request body.\n *\n * @template R The type of the data expected in the response.\n * @param init The initial value for the fetch state.\n * @param options The options for the fetch request, including the URL and method.\n * @returns A `ReadableRef` containing the `FetchState` of the request.\n */\nexport function fetchRef<R>(init: R, options: FetchOptions & { method: 'GET' | 'DELETE' }): ConstantRef<FetchState<R>>;\n\n/**\n * Creates a readable Svelte store that manages the state of a fetch request.\n * This overload is for POST, PUT, or PATCH requests, which typically include a request body.\n *\n * @template R The type of the data expected in the response.\n * @template P The type of the request body.\n * @param init The initial value for the fetch state.\n * @param options The options for the fetch request, including the URL, method, and body.\n * @returns A `ReadableRef` containing the `FetchState` of the request.\n */\nexport function fetchRef<R, P>(\n  init: R,\n  options: FetchOptions & { method: 'POST' | 'PUT' | 'PATCH'; body: P }\n): ConstantRef<FetchState<R>>;\n/** @internal */\nexport function fetchRef<R>(init: R, options: FetchOptions): ConstantRef<FetchState<R>> {\n  const state = fetchState(init, options);\n  return constantRef(state);\n}\n\n/**\n * Creates a readable Svelte store that manages the state of a streaming request.\n * This overload is for GET or DELETE requests, which typically do not have a request body.\n *\n * @template R The type of the data expected in the response.\n * @param init The initial value for the fetch state.\n * @param options The options for the stream request, including the URL and method.\n * @returns A `ReadableRef` containing the `FetchState` of the request.\n */\nexport function streamRef<R>(\n  init: R,\n  options: StreamOptions<R> & { method: 'GET' | 'DELETE' }\n): ConstantRef<FetchState<R>>;\n\n/**\n * Creates a readable Svelte store that manages the state of a streaming request.\n * This overload is for POST, PUT, or PATCH requests, which typically include a request body.\n *\n * @template R The type of the data expected in the response.\n * @template P The type of the request body.\n * @param init The initial value for the fetch state.\n * @param options The options for the stream request, including the URL, method, and body.\n * @returns A `ReadableRef` containing the `FetchState` of the request.\n */\nexport function streamRef<R, P>(\n  init: R,\n  options: StreamOptions<R> & { method: 'POST' | 'PUT' | 'PATCH'; body: P }\n): ConstantRef<FetchState<R>>;\n\n/** @internal */\nexport function streamRef<R>(init: R, options: StreamOptions<R>): ConstantRef<FetchState<R>> {\n  const state = streamState(init, options);\n  return constantRef(state);\n}\n","import type { HistoryOptions, HistoryState, State } from '@anchorlib/core';\nimport { history } from '@anchorlib/core';\nimport type { ConstantRef } from './types.js';\nimport { constantRef } from './ref.js';\n\n/**\n * Creates a readable Svelte store that reflects the history state of a given Anchor state.\n * @param state The initial Anchor state.\n * @param options Optional history options.\n * @returns A readable Svelte store containing the history state.\n */\nexport function historyRef<T extends State>(state: T, options?: HistoryOptions): ConstantRef<HistoryState> {\n  const historyState = history(state, options);\n  return constantRef(historyState);\n}\n","import {\n  anchor,\n  type Immutable,\n  type ImmutableOutput,\n  type LinkableSchema,\n  type ModelInput,\n  type Mutable,\n  type MutablePart,\n  type MutationKey,\n  type State,\n  type StateBaseOptions,\n  type StateOptions,\n} from '@anchorlib/core';\nimport { variableRef } from './ref.js';\nimport type { ConstantRef, VariableRef } from './types.js';\n\n/**\n * Creates an immutable ref from a state object.\n *\n * @template T The type of the state object.\n * @template S The type of the linkable schema.\n * @param init The initial state object.\n * @param options Optional state options.\n * @returns A VariableRef containing the immutable state.\n */\nexport function immutableRef<T extends State, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  options?: StateOptions<S>\n): VariableRef<Immutable<T>>;\n\n/**\n * Creates an immutable ref from a model input and a schema.\n *\n * @template S The type of the linkable schema.\n * @template T The type of the model input.\n * @param init The initial model input.\n * @param schema The linkable schema.\n * @param options Optional base state options.\n * @returns A VariableRef containing the immutable output of the schema.\n */\nexport function immutableRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  init: T,\n  schema: S,\n  options?: StateBaseOptions\n): VariableRef<ImmutableOutput<S>>;\n\n/** Implementation of `immutableRef` overloads. */\nexport function immutableRef<T extends State, S extends LinkableSchema = LinkableSchema>(\n  init: T,\n  schemaOptions?: S | StateOptions,\n  options?: StateOptions<S>\n): VariableRef<Immutable<T>> {\n  const state = anchor.immutable(init as never, schemaOptions as never, options);\n  return variableRef(state) as VariableRef<Immutable<T>>;\n}\n\n/**\n * Creates a writable ref from a state object.\n *\n * @template T The type of the state object.\n * @param state The initial state object.\n * @returns A ConstantRef containing the mutable state.\n */\nexport function writableRef<T extends State>(state: T): ConstantRef<Mutable<T>>;\n\n/**\n * Creates a writable ref from a state object and a list of contracts.\n *\n * @template T The type of the state object.\n * @template K The type of the mutation keys.\n * @param state The initial state object.\n * @param contracts A list of mutation keys.\n * @returns A ConstantRef containing the mutable part of the state.\n */\nexport function writableRef<T extends State, K extends MutationKey<T>[]>(\n  state: T,\n  contracts: K\n): VariableRef<MutablePart<T, K>>;\n\n/** Implementation of `writableRef` overloads. */\nexport function writableRef<T extends State, K extends MutationKey<T>[]>(state: T, contracts?: K): ConstantRef<T> {\n  const writableState = anchor.writable(state, contracts);\n  return variableRef(writableState) as ConstantRef<T>;\n}\n","import {\n  anchor,\n  captureStack,\n  type ImmutableOutput,\n  type LinkableSchema,\n  type ModelInput,\n  type ModelOutput,\n  type ObjLike,\n  type StateBaseOptions,\n  type StateExceptionMap,\n} from '@anchorlib/core';\nimport type { ConstantRef, VariableRef } from './types.js';\nimport { constantRef, isRef, REF_REGISTRY, variableRef } from './ref.js';\n\n/**\n * Creates a model reference with mutable state.\n *\n * @template S - The linkable schema type\n * @template T - The model input type that extends the schema\n * @param schema - The schema to use for the model\n * @param init - The initial value for the model\n * @param options - Optional state configuration\n * @returns A variable reference containing the model output\n */\nexport function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  schema: S,\n  init: T,\n  options?: StateBaseOptions\n): VariableRef<ModelOutput<S>>;\n\n/**\n * Creates a model reference with immutable state.\n *\n * @template S - The linkable schema type\n * @template T - The model input type that extends the schema\n * @param schema - The schema to use for the model\n * @param init - The initial value for the model\n * @param options - State configuration with immutable flag set to true\n * @returns A variable reference containing the immutable output\n */\nexport function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  schema: S,\n  init: T,\n  options: StateBaseOptions & { immutable: true }\n): VariableRef<ImmutableOutput<S>>;\n\nexport function modelRef<S extends LinkableSchema, T extends ModelInput<S>>(\n  schema: S,\n  init: T,\n  options?: StateBaseOptions\n) {\n  const state = anchor(init, schema, options);\n  return variableRef(state);\n}\n\n/**\n * Creates a constant reference that maps exceptions for a given state object or array.\n *\n * @template T - The type of the input state, must be an object-like or array type\n * @param state - The input state object or array to create exception mappings for\n * @returns A ConstantRef containing the StateExceptionMap for the provided state\n */\nexport function exceptionRef<T extends ObjLike | Array<unknown>>(\n  state: T | VariableRef<T>\n): ConstantRef<StateExceptionMap<T>> {\n  if (isRef(state)) {\n    state = REF_REGISTRY.get(state as VariableRef<unknown>)!.value as T;\n\n    captureStack.violation.general(\n      'VariableRef passing detected:',\n      'Attempted to capture exception on a VariableRef.',\n      new Error('Unexpected VariableRef passing'),\n      [\n        `While it works, it won't update when the variable value itself changed.`,\n        `We always recommend passing the state directly instead of passing the VariableRef.`,\n      ],\n      exceptionRef\n    );\n  }\n\n  const exception = anchor.catch(state);\n  return constantRef(exception);\n}\n","import { anchor, type KeyLike, type State } from '@anchorlib/core';\nimport { constantRef } from './ref.js';\nimport type { ConstantRef } from './types.js';\n\nexport type Props = {\n  [key: string]: KeyLike | State;\n};\n\nexport type PropsRef<T extends Props> = {\n  [K in keyof T]: T[K] extends State ? ConstantRef<T[K]> : T[K];\n};\n\n/**\n * Creates a reactive reference object from the provided props.\n * For each property in the input props:\n * - If the value is a State object, it will be converted to a derived ref using derivedRef\n * - Otherwise, the value will be kept as is\n *\n * @template T - The type of props extending Props\n * @param {T} props - The input props object containing KeyLike or State values\n * @returns {PropsRef<T>} A new object with State values converted to Refs\n */\nexport function propsRef<T extends Props>(props: T): PropsRef<T> {\n  const ref = {} as Props;\n\n  for (const [key, value] of Object.entries(props)) {\n    if (anchor.has(value as State)) {\n      ref[key] = constantRef(value as State) as ConstantRef<T[keyof T]>;\n    } else {\n      ref[key] = value as T[keyof T];\n    }\n  }\n\n  return ref as PropsRef<T>;\n}\n","import { type Readable } from 'svelte/store';\nimport { createObserver } from '@anchorlib/core';\nimport type { RefSubscriber } from './types.js';\nimport { onDestroy } from 'svelte';\n\n/**\n * Creates a Svelte readable store that observes a reactive function and updates its subscribers\n * when the observed value changes. The function automatically handles observer lifecycle\n * and cleanup using Svelte's onDestroy hook.\n *\n * @template R - The type of the observed value\n * @param observe - A function that returns the value to be observed\n * @returns A Svelte readable store containing the observed value\n */\nexport function observedRef<R>(observe: () => R): Readable<R> {\n  const subscribers = new Set<RefSubscriber<R>>();\n  const observer = createObserver(() => {\n    update();\n  });\n\n  let current = observer.run(observe);\n\n  const update = () => {\n    current = observer.run(observe);\n    subscribers.forEach((handler) => handler(current));\n  };\n\n  const subscribe = (handler: RefSubscriber<R>) => {\n    handler(current);\n    subscribers.add(handler);\n\n    return () => {\n      subscribers.delete(handler);\n    };\n  };\n\n  onDestroy(() => {\n    observer.destroy();\n  });\n\n  return { subscribe, set: () => {} } as Readable<R>;\n}\n"]}

package/dist/storage/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/storage/kv.ts","../../src/storage/persistent.ts","../../src/storage/session.ts","../../src/storage/table.ts"],"names":["constantRef","onDestroy"],"mappings":";;;;;;AAgBO,SAAS,KAAA,CAA0B,MAAc,IAAA,EAAkC;AACxF,EAAA,MAAM,KAAA,GAAQ,EAAA,CAAG,IAAA,EAAM,IAAI,CAAA;AAE3B,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,EAAA,CAAG,MAAM,KAAK,CAAA;AAAA,EAChB,CAAC,CAAA;AAED,EAAA,OAAO,YAAY,KAAK,CAAA;AAC1B;ACPO,SAAS,aAAA,CACd,IAAA,EACA,IAAA,EACA,OAAA,EACgB;AAChB,EAAA,MAAM,KAAA,GAAQ,UAAA,CAAW,IAAA,EAAM,IAAA,EAAM,OAAO,CAAA;AAC5C,EAAA,OAAOA,YAAe,KAAK,CAAA;AAC7B;ACPO,SAAS,UAAA,CACd,IAAA,EACA,IAAA,EACA,OAAA,EACgB;AAChB,EAAA,MAAM,KAAA,GAAQ,OAAA,CAAQ,IAAA,EAAM,IAAA,EAAM,OAAO,CAAA;AACzC,EAAA,OAAOA,YAAe,KAAK,CAAA;AAC7B;ACJO,SAAS,eACd,SAAA,EACA,OAAA,GAAU,GACV,OAAA,EACA,UAAA,EACA,SAAS,SAAA,EACO;AAChB,EAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,IAAA,SAAA,GAAY,WAAA,CAAkB,SAAA,EAAW,OAAA,EAAS,OAAA,EAAS,YAAY,MAAM,CAAA;AAAA,EAC/E;AAEA,EAAA,MAAM,QAAA,GAAW,SAAA;AAEjB,EAAA,OAAO;AAAA,IACL,IAAI,EAAA,EAAY;AACd,MAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,EAAE,CAAA;AAE7B,MAAAC,UAAU,MAAM;AACd,QAAA,QAAA,CAAS,MAAM,EAAE,CAAA;AAAA,MACnB,CAAC,CAAA;AAED,MAAA,OAAOD,YAAY,KAAK,CAAA;AAAA,IAC1B,CAAA;AAAA,IACA,IAAI,OAAA,EAAY;AACd,MAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,GAAA,CAAI,OAAO,CAAA;AAElC,MAAAC,UAAU,MAAM;AACd,QAAA,QAAA,CAAS,KAAA,CAAM,KAAA,CAAM,IAAA,CAAK,EAAE,CAAA;AAAA,MAC9B,CAAC,CAAA;AAED,MAAA,OAAOD,YAAY,KAAK,CAAA;AAAA,IAC1B,CAAA;AAAA,IACA,IAAA,CAAK,MAAA,EAAoC,KAAA,EAAgB,SAAA,EAAgC;AACvF,MAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,IAAA,CAAK,MAAA,EAAQ,OAAO,SAAS,CAAA;AACpD,MAAA,OAAOA,YAAY,KAAK,CAAA;AAAA,IAC1B,CAAA;AAAA,IACA,WAAA,CAAY,IAAA,EAAe,MAAA,EAAoC,KAAA,EAAgB,SAAA,EAAgC;AAC7G,MAAA,MAAM,QAAQ,QAAA,CAAS,WAAA,CAAY,IAAA,EAAM,MAAA,EAAQ,OAAO,SAAS,CAAA;AACjE,MAAA,OAAOA,YAAY,KAAK,CAAA;AAAA,IAC1B,CAAA;AAAA,IACA,OAAO,EAAA,EAAY;AACjB,MAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,MAAA,CAAO,EAAE,CAAA;AAChC,MAAA,OAAOA,YAAY,KAAK,CAAA;AAAA,IAC1B,CAAA;AAAA,IACA,KAAK,KAAA,EAAY;AACf,MAAA,QAAA,CAAS,KAAK,KAAK,CAAA;AACnB,MAAA,OAAO,IAAA;AAAA,IACT,CAAA;AAAA,IACA,KAAA,GAAQ;AACN,MAAA,OAAO,QAAA;AAAA,IACT;AAAA,GACF;AACF","file":"index.js","sourcesContent":["import { kv, type KVState, type Storable } from '@anchorlib/storage/db';\nimport type { ConstantRef } from '@base/index.js';\nimport { constantRef } from '@base/index.js';\nimport { onDestroy } from 'svelte';\n\n/**\n * Creates a reactive reference to a key-value store state.\n *\n * This function initializes a key-value store with the given name and initial value,\n * and automatically cleans up the store subscription when the component is destroyed.\n *\n * @template T - The type of the stored value, must extend Storable\n * @param name - The unique identifier for the key-value store\n * @param init - The initial value for the store\n * @returns A reactive reference to the key-value store state\n */\nexport function kvRef<T extends Storable>(name: string, init: T): ConstantRef<KVState<T>> {\n  const state = kv(name, init);\n\n  onDestroy(() => {\n    kv.leave(state);\n  });\n\n  return constantRef(state);\n}\n","import type { LinkableSchema, ObjLike, StateOptions } from '@anchorlib/core';\nimport type { ConstantRef } from '@base/index.js';\nimport { constantRef } from '@base/index.js';\nimport { persistent } from '@anchorlib/storage';\n\n/**\n * Creates a persistent reactive reference using the provided name, initial value, and options.\n * The persistentRef is tied to the browser's local storage, meaning its value will persist\n * across page reloads and browser sessions until explicitly cleared.\n *\n * @template T - The type of the initial value, must extend object-like structure.\n * @template S - The schema type for linkable validation, defaults to LinkableSchema.\n * @param name - A unique string identifier for the local storage key.\n * @param init - The initial value to be stored in local storage.\n * @param options - Optional configuration for state behavior and validation schema.\n * @returns A WritableRef<T> that provides reactive access and modification capabilities.\n */\nexport function persistentRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(\n  name: string,\n  init: T,\n  options?: StateOptions<S>\n): ConstantRef<T> {\n  const state = persistent(name, init, options);\n  return constantRef<T>(state);\n}\n","import type { LinkableSchema, ObjLike, StateOptions } from '@anchorlib/core';\nimport type { ConstantRef } from '@base/index.js';\nimport { constantRef } from '@base/index.js';\nimport { session } from '@anchorlib/storage';\n\n/**\n * Creates a session-scoped reactive reference using the provided name, initial value, and options.\n * The sessionRef is tied to the browser's session storage, meaning its value will persist\n * across page reloads but not after the session ends (e.g., tab/window closed).\n *\n * @template T - The type of the initial value, must extend object-like structure.\n * @template S - The schema type for linkable validation, defaults to LinkableSchema.\n * @param name - A unique string identifier for the session storage key.\n * @param init - The initial value to be stored in session storage.\n * @param options - Optional configuration for state behavior and validation schema.\n * @returns A WritableRef<T> that provides reactive access and modification capabilities.\n */\nexport function sessionRef<T extends ObjLike, S extends LinkableSchema = LinkableSchema>(\n  name: string,\n  init: T,\n  options?: StateOptions<S>\n): ConstantRef<T> {\n  const state = session(name, init, options);\n  return constantRef<T>(state);\n}\n","import {\n  createTable,\n  type FilterFn,\n  type InferRec,\n  type ReactiveTable,\n  type Rec,\n  type Row,\n} from '@anchorlib/storage/db';\nimport { onDestroy } from 'svelte';\nimport { constantRef } from '@base/index.js';\nimport type { TableRef } from './types.js';\n\nexport function createTableRef<T extends ReactiveTable<Rec>>(table: T): TableRef<InferRec<T>>;\nexport function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(\n  name: string,\n  version?: number,\n  indexes?: (keyof R)[],\n  remIndexes?: (keyof R)[],\n  dbName?: string\n): TableRef<T, R>;\nexport function createTableRef<T extends Rec, R extends Row<T> = Row<T>>(\n  tableName: string | ReactiveTable<T>,\n  version = 1,\n  indexes?: (keyof R)[],\n  remIndexes?: (keyof R)[],\n  dbName = tableName as string\n): TableRef<T, R> {\n  if (typeof tableName === 'string') {\n    tableName = createTable<T, R>(tableName, version, indexes, remIndexes, dbName);\n  }\n\n  const tableRef = tableName as ReactiveTable<T, R>;\n\n  return {\n    get(id: string) {\n      const state = tableRef.get(id);\n\n      onDestroy(() => {\n        tableRef.leave(id);\n      });\n\n      return constantRef(state);\n    },\n    add(payload: T) {\n      const state = tableRef.add(payload);\n\n      onDestroy(() => {\n        tableRef.leave(state.data.id);\n      });\n\n      return constantRef(state);\n    },\n    list(filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection) {\n      const state = tableRef.list(filter, limit, direction);\n      return constantRef(state);\n    },\n    listByIndex(name: keyof R, filter?: IDBKeyRange | FilterFn<R>, limit?: number, direction?: IDBCursorDirection) {\n      const state = tableRef.listByIndex(name, filter, limit, direction);\n      return constantRef(state);\n    },\n    remove(id: string) {\n      const state = tableRef.remove(id);\n      return constantRef(state);\n    },\n    seed(seeds: R[]) {\n      tableRef.seed(seeds);\n      return this;\n    },\n    table() {\n      return tableRef;\n    },\n  };\n}\n"]}

package/dist/types-CsfltB4A.d.ts

@@ -1,16 +0,0 @@
-type StateRef<T> = {
-    value: T;
-};
-type ConstantRef<T> = {
-    get value(): T;
-    publish(): void;
-    subscribe(fn: RefSubscriber<T>): RefUnsubscribe;
-};
-type VariableRef<T> = ConstantRef<T> & {
-    set(value: T): void;
-    set value(value: T);
-};
-type RefSubscriber<T> = (current: T) => void;
-type RefUnsubscribe = () => void;
-
-export type { ConstantRef as C, RefSubscriber as R, StateRef as S, VariableRef as V, RefUnsubscribe as a };