@bayonai/offline 0.8.0 → 0.9.0

package/dist-cjs/browserRecovery.d.ts

@@ -0,0 +1,42 @@
+import { type PendingWriteRecord, type PendingWriteStore, type PendingWriteSync, type SyncPendingWritesResult } from "./pendingWrites.js";
+import type { BrowserPendingWriteRecoveryCoordination } from "./browserCoordination.js";
+export declare const initialPendingWriteRetryDelayMs = 2000;
+export declare const maxPendingWriteRetryDelayMs = 60000;
+export type BrowserPendingWriteRecoveryEnvironment = {
+    addEventListener: (type: "focus" | "offline" | "online", listener: () => void) => void;
+    clearTimeout: (timer: ReturnType<typeof setTimeout>) => void;
+    isOnline: () => boolean;
+    removeEventListener: (type: "focus" | "offline" | "online", listener: () => void) => void;
+    setTimeout: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+};
+export type BrowserPendingWriteRecovery<Payload> = {
+    /** Signals that a caller has persisted a record outside the store subscription. */
+    notifyQueued: () => void;
+    /** Runs one immediate, silent recovery attempt when the browser is online. */
+    recoverNow: () => Promise<SyncPendingWritesResult | null>;
+    start: () => void;
+    stop: () => void;
+};
+type BrowserPendingWriteRecoveryOptions<Payload> = {
+    /** Optional BroadcastChannel/Web Locks coordination supplied by the package factory. */
+    coordination?: BrowserPendingWriteRecoveryCoordination;
+    environment?: BrowserPendingWriteRecoveryEnvironment;
+    initialRetryDelayMs?: number;
+    maxRetryDelayMs?: number;
+    /** Diagnostic callback only. Recovery never renders or presents product UI. */
+    onError?: (error: unknown) => void;
+    /** Diagnostic callback only. Recovery never renders or presents product UI. */
+    onResult?: (result: SyncPendingWritesResult) => void;
+    scopeKey?: string;
+    select?: (record: PendingWriteRecord<Payload>) => boolean;
+    store: PendingWriteStore<Payload>;
+} & ({
+    /** Runs one complete host-owned recovery pass, such as through an ordered executor. */
+    recover: () => Promise<SyncPendingWritesResult>;
+    sync?: never;
+} | {
+    recover?: never;
+    sync: PendingWriteSync<Payload>;
+});
+export declare function createBrowserPendingWriteRecovery<Payload>(options: BrowserPendingWriteRecoveryOptions<Payload>): BrowserPendingWriteRecovery<Payload>;
+export {};

package/dist-cjs/durableCommandStore.d.ts

@@ -0,0 +1,49 @@
+import { type PendingWriteRecord, type PendingWriteStore } from "./pendingWrites.js";
+export type DurableCommandErrorCategory = "auth" | "conflict" | "connectivity" | "local-storage" | "permission" | "unexpected" | "validation";
+export type DurableCommandOperation<Command> = {
+    command: Command;
+    error?: DurableCommandErrorCategory;
+    id: string;
+    status: "accepted" | "failed" | "syncing";
+};
+export type DurableCommandSnapshot<State, Command> = {
+    operations: DurableCommandOperation<Command>[];
+    state: State;
+};
+export type DurableCommandDispatch = {
+    accepted: Promise<void>;
+    operationId: string;
+};
+export type DurableCommandExecutionContext = {
+    /** Stable across retries so the remote command can be idempotent. */
+    operationId: string;
+};
+export type DurableCommandStore<State, Command, Scope> = {
+    cancel: (operationId: string) => Promise<boolean>;
+    close: () => void;
+    dispatch: (command: Command, options?: {
+        notBefore?: string;
+    }) => DurableCommandDispatch;
+    getSnapshot: () => DurableCommandSnapshot<State, Command>;
+    recover: () => Promise<void>;
+    refresh: (scope: Scope) => Promise<void>;
+    subscribe: (listener: () => void) => () => void;
+};
+/**
+ * Hosts provide domain projection and transport; this package only owns the
+ * durable command lifecycle. A command becomes visible immediately, but is
+ * never sent remotely until IndexedDB has accepted it.
+ */
+export declare function createDurableCommandStore<State, Command, Scope, Result = unknown>({ canCancel, classifyError, createId, execute, initialState, load, now, project, reconcile, shouldRetry, store, }: {
+    canCancel?: (command: Command, now: string) => boolean;
+    classifyError?: (error: unknown) => DurableCommandErrorCategory;
+    createId?: () => string;
+    execute: (command: Command, context: DurableCommandExecutionContext) => Promise<Result>;
+    initialState: State;
+    load: (scope: Scope) => Promise<State>;
+    now?: () => string;
+    project: (state: State, commands: readonly PendingWriteRecord<Command>[]) => State;
+    reconcile?: (state: State, command: Command, result: Result) => State;
+    shouldRetry?: (category: DurableCommandErrorCategory, command: Command) => boolean;
+    store: PendingWriteStore<Command>;
+}): DurableCommandStore<State, Command, Scope>;

package/dist-cjs/idbDriver.d.ts

@@ -0,0 +1,26 @@
+export type BrowserKeyValueDriver = {
+    clear: () => Promise<void>;
+    close: () => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    deleteIf: (key: string, predicate: KeyValuePredicate) => Promise<boolean>;
+    get: (key: string) => Promise<unknown | null>;
+    list: () => Promise<unknown[]>;
+    listEntries: () => Promise<Array<{
+        key: string;
+        value: unknown;
+    }>>;
+    set: (key: string, value: unknown) => Promise<void>;
+    setIf: (key: string, value: unknown, predicate: KeyValuePredicate) => Promise<boolean>;
+};
+export type KeyValuePredicate = (value: unknown | null) => boolean;
+export type BrowserKeyValueDriverOptions = {
+    databaseName: string;
+    databaseVersion?: number;
+    indexedDB?: IDBFactory;
+    operationTimeoutMs: number;
+    storeName: string;
+};
+export declare class OfflineStorageError extends Error {
+    name: string;
+}
+export declare function createIdbKeyValueDriver({ databaseName, databaseVersion, indexedDB, operationTimeoutMs, storeName, }: BrowserKeyValueDriverOptions): BrowserKeyValueDriver | null;

package/dist-cjs/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./readCache.js";
+export * from "./pendingWrites.js";
+export * from "./browserRecovery.js";
+export * from "./browserCoordination.js";
+export * from "./browserFallbackRecovery.js";
+export * from "./durableCommandStore.js";
+export { OfflineStorageError } from "./idbDriver.js";

package/dist-cjs/pendingWrites.d.ts

@@ -0,0 +1,179 @@
+import { type BrowserKeyValueDriverOptions } from "./idbDriver.js";
+export declare const pendingWriteSchemaVersion = 1;
+export declare const pendingWriteOperationTimeoutMs = 2000;
+export declare const pendingWriteSyncLeaseTimeoutMs = 60000;
+export type PendingWriteStatus = "pending" | "syncing" | "failed";
+export type PendingWriteRecord<Payload = unknown> = {
+    error?: string;
+    id: string;
+    /** Do not execute this accepted command before this ISO timestamp. */
+    notBefore?: string;
+    payload: Payload;
+    savedAt: string;
+    snapshotId: string;
+    /** Timestamp of the active remote-sync claim, absent when not owned. */
+    syncingAt?: string;
+    syncStatus: PendingWriteStatus;
+};
+export type PendingWriteRecordInput<Payload = unknown> = Omit<PendingWriteRecord<Payload>, "snapshotId"> & {
+    snapshotId?: string;
+};
+export type PendingWritePayloadNormalizer<Payload = unknown> = (payload: unknown) => Payload | null;
+export type PendingWriteDriver = {
+    clear: (key: string) => Promise<void>;
+    clearIf: (key: string, predicate: PendingWritePredicate) => Promise<boolean>;
+    clearAll?: () => Promise<void>;
+    close?: () => Promise<void>;
+    get: (key: string) => Promise<unknown | null>;
+    list: () => Promise<unknown[]>;
+    listEntries?: () => Promise<Array<{
+        key: string;
+        value: unknown;
+    }>>;
+    set: (key: string, value: unknown) => Promise<void>;
+    setIf: (key: string, value: unknown, predicate: PendingWritePredicate) => Promise<boolean>;
+};
+export type PendingWritePredicate = (value: unknown | null) => boolean;
+export type PendingWriteStoreChange<Payload = unknown> = {
+    record: PendingWriteRecord<Payload>;
+    type: "set";
+} | {
+    id: string;
+    type: "clear";
+} | {
+    type: "clearAll";
+} | {
+    record: PendingWriteRecord<Payload>;
+    type: "replace";
+};
+export type PendingWriteStoreChangeListener<Payload = unknown> = (change: PendingWriteStoreChange<Payload>) => void;
+export type PendingWriteStore<Payload = unknown> = {
+    claimIfSnapshotId: (id: string, snapshotId: string, record: PendingWriteRecord<Payload>, now: string) => Promise<boolean>;
+    clear: (id: string) => Promise<void>;
+    clearAll: () => Promise<void>;
+    clearIfSnapshotId: (id: string, snapshotId: string) => Promise<boolean>;
+    close: () => Promise<void>;
+    get: (id: string) => Promise<PendingWriteRecord<Payload> | null>;
+    list: () => Promise<Array<PendingWriteRecord<Payload>>>;
+    replaceIfSnapshotId: (id: string, snapshotId: string, record: PendingWriteRecord<Payload>) => Promise<boolean>;
+    set: (record: PendingWriteRecordInput<Payload>) => Promise<PendingWriteRecord<Payload>>;
+    /**
+     * Observes changes made through this in-memory store instance. It deliberately
+     * does not claim cross-tab/process delivery.
+     */
+    subscribe: (listener: PendingWriteStoreChangeListener<Payload>) => () => void;
+};
+export type PendingWriteStoreOptions<Payload = unknown> = {
+    keyPrefix: string;
+    normalizeLegacyRecord?: PendingWritePayloadNormalizer<PendingWriteRecordInput<Payload>>;
+    normalizePayload?: PendingWritePayloadNormalizer<Payload>;
+    schemaVersion?: number;
+};
+export type BrowserPendingWriteStoreOptions<Payload = unknown> = Partial<Pick<BrowserKeyValueDriverOptions, "databaseVersion" | "indexedDB">> & PendingWriteStoreOptions<Payload> & {
+    databaseName: string;
+    operationTimeoutMs?: number;
+    storeName: string;
+};
+export type PendingWriteKeyOptions = {
+    id: string;
+    prefix: string;
+};
+export type SyncPendingWriteResult = {
+    status: "idle";
+} | {
+    status: "synced";
+} | {
+    status: "superseded";
+} | {
+    error: string;
+    failure: unknown;
+    status: "failed";
+};
+export type SyncPendingWritesResult = {
+    attempted: number;
+    failed: number;
+    idle: number;
+    /** Records still selected after this attempt, including newer superseding writes. */
+    remaining: number;
+    superseded: number;
+    synced: number;
+};
+export type PendingWriteSyncContext = {
+    /** Stable durable-record identity; safe to use as a remote idempotency key. */
+    recordId: string;
+};
+export type PendingWriteSync<Payload, Result = unknown> = (payload: Payload, context: PendingWriteSyncContext) => Promise<Result>;
+export type RunPendingWriteResult<TResult, TQueued> = {
+    result: TResult;
+    status: "synced";
+} | {
+    queued: TQueued;
+    status: "queued";
+};
+export type PendingWriteRunOptions<TResult, TQueued> = {
+    enqueue: () => Promise<TQueued>;
+    isOnline: () => boolean;
+    shouldQueue: (error: unknown) => boolean;
+    write: () => Promise<TResult>;
+};
+/**
+ * Serializes recovery and new writes for one caller-defined scope.
+ *
+ * A queued write that cannot be replayed stays ahead of later writes. This
+ * preserves remote write order; callers retain ownership of scope selection
+ * and idempotent remote mutation semantics.
+ */
+export type OrderedPendingWriteExecutor<Payload> = {
+    recover: () => Promise<SyncPendingWritesResult>;
+    run: <TResult, TQueued>(options: PendingWriteRunOptions<TResult, TQueued>) => Promise<RunPendingWriteResult<TResult, TQueued>>;
+};
+export type PendingWriteSummary = {
+    failedCount: number;
+    pendingCount: number;
+    syncingCount: number;
+    totalCount: number;
+};
+export declare function createPendingWriteStore<Payload = unknown>(driver: PendingWriteDriver, { keyPrefix, normalizeLegacyRecord, normalizePayload, schemaVersion, }: PendingWriteStoreOptions<Payload>): PendingWriteStore<Payload>;
+export declare function createMemoryPendingWriteDriver(): PendingWriteDriver;
+export declare function createBrowserPendingWriteDriver({ databaseName, databaseVersion, indexedDB, operationTimeoutMs, storeName, }: Omit<BrowserPendingWriteStoreOptions, "keyPrefix" | "normalizePayload" | "schemaVersion">): PendingWriteDriver | null;
+export declare function createBrowserPendingWriteStore<Payload = unknown>({ databaseName, databaseVersion, indexedDB, keyPrefix, normalizeLegacyRecord, normalizePayload, operationTimeoutMs, schemaVersion, storeName, }: BrowserPendingWriteStoreOptions<Payload>): PendingWriteStore<Payload>;
+export declare function createPendingWriteKey({ id, prefix }: PendingWriteKeyOptions): string;
+export declare function createPendingWriteSnapshotId(): string;
+export declare function syncPendingWrite<Payload>({ id, now, store, sync, }: {
+    id: string;
+    now?: () => string;
+    store: PendingWriteStore<Payload>;
+    sync: PendingWriteSync<Payload>;
+}): Promise<SyncPendingWriteResult>;
+/**
+ * Replays selected writes oldest first and coalesces overlapping runs for the
+ * same store/scope. Callers own the selection predicate and idempotent remote
+ * mutation semantics.
+ */
+export declare function syncPendingWrites<Payload>({ now, scopeKey, select, stopOnFailure, store, sync, }: {
+    now?: () => string;
+    scopeKey?: string;
+    select?: (record: PendingWriteRecord<Payload>) => boolean;
+    /** Preserve caller ordering by leaving later records for a future retry. */
+    stopOnFailure?: boolean;
+    store: PendingWriteStore<Payload>;
+    sync: PendingWriteSync<Payload>;
+}): Promise<SyncPendingWritesResult>;
+/**
+ * Attempts a remote write now and persists a caller-created durable fallback
+ * only when offline or when the supplied retry classifier accepts the error.
+ */
+export declare function runPendingWrite<TResult, TQueued>({ enqueue, isOnline, shouldQueue, write, }: PendingWriteRunOptions<TResult, TQueued>): Promise<RunPendingWriteResult<TResult, TQueued>>;
+export declare function summarizePendingWrites<Payload>(records: Array<PendingWriteRecord<Payload>>): PendingWriteSummary;
+/**
+ * Creates a serial execution lane for a durable scope such as one user or
+ * workspace. Use its `recover` method for background replay and `run` for new
+ * writes so a newer remote mutation cannot overtake an older queued mutation.
+ */
+export declare function createOrderedPendingWriteExecutor<Payload>({ now, scopeKey, select, store, sync, }: {
+    now?: () => string;
+    scopeKey?: string;
+    select?: (record: PendingWriteRecord<Payload>) => boolean;
+    store: PendingWriteStore<Payload>;
+    sync: PendingWriteSync<Payload>;
+}): OrderedPendingWriteExecutor<Payload>;

package/dist-cjs/pendingWrites.js

@@ -31,6 +31,29 @@ function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, nor
             }
         }
     };
+    async function listScopedRecords() {
+        const readOptions = { normalizeLegacyRecord, normalizePayload };
+        const entries = await driver.listEntries?.();
+        if (entries) {
+            const keyPrefixBoundary = `${keyPrefix}:`;
+            return entries
+                .filter(({ key }) => key.startsWith(keyPrefixBoundary))
+                .map(({ value }) => toPendingWriteEnvelope(value, schemaVersion, readOptions)
+                ?.record)
+                .filter((record) => Boolean(record));
+        }
+        // Compatibility path for custom drivers created before listEntries was
+        // available. Point reads prove that each candidate belongs to this prefix.
+        const candidateIds = new Set((await driver.list())
+            .map((value) => toPendingWriteEnvelope(value, schemaVersion, readOptions)
+            ?.record.id)
+            .filter((id) => Boolean(id)));
+        const records = await Promise.all([...candidateIds].map(async (id) => {
+            const value = await driver.get(createPendingWriteKey({ id, prefix: keyPrefix }));
+            return toPendingWriteEnvelope(value, schemaVersion, readOptions)?.record;
+        }));
+        return records.filter((record) => Boolean(record));
+    }
     return {
         async claimIfSnapshotId(id, snapshotId, record, now) {
             const claimed = await driver.setIf(createPendingWriteKey({ id, prefix: keyPrefix }), { record, schemaVersion }, (value) => {
@@ -51,7 +74,20 @@ function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, nor
             notify({ id, type: "clear" });
         },
         async clearAll() {
-            await driver.clearAll();
+            const entries = await driver.listEntries?.();
+            if (entries) {
+                const keyPrefixBoundary = `${keyPrefix}:`;
+                await Promise.all(entries
+                    .filter(({ key }) => key.startsWith(keyPrefixBoundary))
+                    .map(({ key }) => driver.clear(key)));
+            }
+            else {
+                const records = await listScopedRecords();
+                await Promise.all(records.map((record) => driver.clearIf(createPendingWriteKey({ id: record.id, prefix: keyPrefix }), (value) => toPendingWriteEnvelope(value, schemaVersion, {
+                    normalizeLegacyRecord,
+                    normalizePayload,
+                })?.record.snapshotId === record.snapshotId)));
+            }
             notify({ type: "clearAll" });
         },
         async clearIfSnapshotId(id, snapshotId) {
@@ -71,13 +107,7 @@ function createPendingWriteStore(driver, { keyPrefix, normalizeLegacyRecord, nor
             return (toPendingWriteEnvelope(await driver.get(createPendingWriteKey({ id, prefix: keyPrefix })), schemaVersion, { normalizeLegacyRecord, normalizePayload })?.record ?? null);
         },
         async list() {
-            return (await driver.list())
-                .map((value) => toPendingWriteEnvelope(value, schemaVersion, {
-                normalizeLegacyRecord,
-                normalizePayload,
-            })?.record)
-                .filter((record) => Boolean(record))
-                .sort((left, right) => left.savedAt.localeCompare(right.savedAt) ||
+            return (await listScopedRecords()).sort((left, right) => left.savedAt.localeCompare(right.savedAt) ||
                 left.id.localeCompare(right.id));
         },
         async replaceIfSnapshotId(id, snapshotId, record) {
@@ -132,6 +162,9 @@ function createMemoryPendingWriteDriver() {
         async list() {
             return [...records.values()];
         },
+        async listEntries() {
+            return [...records].map(([key, value]) => ({ key, value }));
+        },
         async set(key, value) {
             records.set(key, value);
         },
@@ -388,7 +421,6 @@ function createUnavailablePendingWriteDriver() {
         async clearIf() {
             return false;
         },
-        async clearAll() { },
         async close() { },
         async get() {
             return null;
@@ -412,6 +444,7 @@ function toPendingWriteDriver(driver) {
         close: driver.close,
         get: driver.get,
         list: driver.list,
+        listEntries: driver.listEntries,
         set: driver.set,
         setIf: driver.setIf,
     };

package/dist-cjs/readCache.d.ts

@@ -0,0 +1,112 @@
+import { type BrowserKeyValueDriverOptions } from "./idbDriver.js";
+export declare const readCacheSchemaVersion = 1;
+export declare const readCacheFreshnessMaxAgeMs = 30000;
+export declare const durableReadCacheFreshnessMaxAgeMs: number;
+export declare const identityReadCacheFreshnessMaxAgeMs: number;
+export declare const browserReadCacheOperationTimeoutMs = 1000;
+export type ReadCacheHit<T> = {
+    fromCache: true;
+    savedAt: string;
+    value: T;
+};
+export type ReadCacheDriver = {
+    clear: () => Promise<void>;
+    close?: () => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    get: (key: string) => Promise<unknown | null>;
+    listEntries?: () => Promise<Array<{
+        key: string;
+        value: unknown;
+    }>>;
+    set: (key: string, value: unknown) => Promise<void>;
+};
+export type ReadCache = {
+    /**
+     * Resolves a stable cache for the duration of a resource load. Dynamic
+     * adapters use this to pin the active account before asynchronous work.
+     */
+    capture?: () => ReadCache;
+    clear: () => Promise<void>;
+    close: () => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    /** Advances a key's generation without deleting its retained value. */
+    invalidate?: (key: string) => void;
+    get: <T>(key: string) => Promise<ReadCacheHit<T> | null>;
+    getVersion: (key: string) => string;
+    set: <T>(key: string, value: T) => Promise<void>;
+    setIfVersion: <T>(key: string, value: T, version: string) => Promise<boolean>;
+};
+export type ReadCachePolicy = {
+    /** Time that a cached value can suppress a remote read. */
+    freshForMs: number;
+    /** Maximum age at which cached data remains eligible as an offline fallback. */
+    retainForMs: number;
+    /** Behavior when revalidation fails while retained data is available. */
+    refreshFailure: "use-retained" | "throw";
+};
+export type ReadCacheStatus = "fresh" | "stale" | "miss";
+/** Payload-free cache lifecycle events suitable for host-owned telemetry. */
+export type ReadCacheOutcome = "fresh-hit" | "stale-hit" | "cache-miss" | "forced-refresh" | "loader-success" | "loader-failure";
+export type ReadThroughCacheResult<T> = {
+    data: T;
+    error: Error | null;
+    fromCache: boolean;
+    stale: boolean;
+    status: ReadCacheStatus;
+};
+export type ReadCacheResourceUpdate<T> = {
+    data: T;
+    error?: Error;
+    fromCache: boolean;
+    status: ReadCacheStatus;
+};
+export type BrowserReadCacheOptions = Partial<Pick<BrowserKeyValueDriverOptions, "databaseVersion" | "indexedDB">> & {
+    databaseName: string;
+    operationTimeoutMs?: number;
+    storeName: string;
+};
+export type ReadCacheKeyOptions = {
+    namespace: string;
+    params?: Record<string, string | number | boolean | null | undefined>;
+    prefix: string;
+    scope: string;
+};
+export declare function createReadCache(driver: ReadCacheDriver): ReadCache;
+export declare function createMemoryReadCacheDriver(): ReadCacheDriver;
+export declare function createBrowserReadCache({ databaseName, databaseVersion, indexedDB, operationTimeoutMs, storeName, }: BrowserReadCacheOptions): ReadCache;
+/**
+ * Deletes only valid read-cache envelopes older than the supplied age. It is
+ * opt-in and returns zero for custom cache adapters that cannot enumerate keys.
+ */
+export declare function pruneReadCache({ cache, maxAgeMs, now, }: {
+    cache: ReadCache;
+    maxAgeMs: number;
+    now?: () => number;
+}): Promise<number>;
+export declare function createReadCacheKey({ namespace, params, prefix, scope, }: ReadCacheKeyOptions): string;
+export declare function readThroughCache<T>({ cache, forceFresh, key, loadFresh, maxAgeMs, onOutcome, policy, }: {
+    cache: ReadCache;
+    /**
+     * Revalidates after advancing the key generation, retaining the prior value
+     * as a possible fallback if refresh fails.
+     */
+    forceFresh?: boolean;
+    key: string;
+    loadFresh: () => Promise<T>;
+    maxAgeMs?: number;
+    onOutcome?: (outcome: ReadCacheOutcome) => void;
+    policy?: ReadCachePolicy;
+}): Promise<ReadThroughCacheResult<T>>;
+export declare function loadReadCacheResource<T>({ cache, forceFresh, key, loadFresh, maxAgeMs, onOutcome, policy, onCacheWriteError, onUpdate, skipCache, }: {
+    cache: ReadCache;
+    /** Revalidate while retaining eligible data as fallback on loader failure. */
+    forceFresh?: boolean;
+    key: string;
+    loadFresh: () => Promise<T>;
+    maxAgeMs?: number;
+    onOutcome?: (outcome: ReadCacheOutcome) => void;
+    policy?: ReadCachePolicy;
+    onCacheWriteError?: (error: Error) => void;
+    onUpdate: (update: ReadCacheResourceUpdate<T>) => void;
+    skipCache?: boolean;
+}): Promise<T>;