@graphrefly/ts 0.0.0

package/dist/append-log-DisvEReb.d.cts

@@ -0,0 +1,189 @@
+import { C as Codec } from './codec-BB7p8fJc.cjs';
+
+/**
+ * Byte storage backends (D82): passive adapter-owned storage, no graph methods.
+ */
+/** Passive byte-addressed backend used by D82 storage binding tiers. */
+interface StorageBackend {
+    get(key: string): undefined | Uint8Array | PromiseLike<undefined | Uint8Array>;
+    put(key: string, value: Uint8Array): void | PromiseLike<void>;
+    putIfAbsent?(key: string, value: Uint8Array): boolean | PromiseLike<boolean>;
+    getVersioned?(key: string): StorageVersionedRead | PromiseLike<StorageVersionedRead>;
+    setIfMatch?(key: string, value: Uint8Array, generation: StorageGeneration): boolean | PromiseLike<boolean>;
+    delete?(key: string): void | PromiseLike<void>;
+    list?(prefix?: string): readonly string[] | PromiseLike<readonly string[]>;
+}
+/** Passive D85 conditional-create capability for multi-writer storage helpers. */
+interface PutIfAbsentStorageBackend extends StorageBackend {
+    putIfAbsent(key: string, value: Uint8Array): boolean | PromiseLike<boolean>;
+}
+/** Opaque D108 per-key generation token for passive storage versioned reads. */
+type StorageGeneration = unknown;
+/** D108 versioned byte read result with explicit present/absent observations. */
+type StorageVersionedRead = {
+    readonly kind: "hit";
+    readonly value: Uint8Array;
+    readonly generation: StorageGeneration;
+} | {
+    readonly kind: "miss";
+    readonly generation: StorageGeneration;
+};
+/** Passive D108 versioned read + generation-conditional set capability. */
+interface VersionedStorageBackend extends StorageBackend {
+    getVersioned(key: string): StorageVersionedRead | PromiseLike<StorageVersionedRead>;
+    setIfMatch(key: string, value: Uint8Array, generation: StorageGeneration): boolean | PromiseLike<boolean>;
+}
+/** Runtime guard for D85 conditional-create capable byte backends. */
+declare function hasStoragePutIfAbsent(backend: StorageBackend): backend is PutIfAbsentStorageBackend;
+/** Require D85 conditional-create support and produce a clear adapter error when absent. */
+declare function requireStoragePutIfAbsent(backend: StorageBackend, label?: string): PutIfAbsentStorageBackend;
+/** Runtime guard for D108 versioned byte backends. */
+declare function hasStorageVersioned(backend: StorageBackend): backend is VersionedStorageBackend;
+/** Require D108 versioned support and produce a clear adapter error when absent. */
+declare function requireStorageVersioned(backend: StorageBackend, label?: string): VersionedStorageBackend;
+/** Browser/storage-adapter shape for deterministic byte helpers (DOM-free for portability). */
+interface WebStorageLike {
+    readonly length?: number;
+    getItem(key: string): string | null | undefined;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    key?(index: number): string | null | undefined;
+    keys?(): readonly string[];
+}
+/** Storage helper options for namespace isolation and logical-key prefixing. */
+interface StorageNamespaceOptions {
+    /**
+     * Optional namespace for logical keys.
+     *
+     * Namespace is part of key mapping only and is not returned from `list()`.
+     */
+    namespace?: string;
+}
+/** Build a deterministic byte backend backed by a browser-like key/value store (D103/D82). */
+declare function webStorageBackend(storage: WebStorageLike, opts?: StorageNamespaceOptions): StorageBackend;
+/** In-memory backend for tests, adapters, and lightweight local storage. */
+interface MemoryBackend extends StorageBackend {
+    readonly entries: ReadonlyMap<string, Uint8Array>;
+    clear(): void;
+}
+/** Create a byte-cloning in-memory backend. */
+declare function memoryBackend(initial?: Iterable<readonly [string, Uint8Array]>): MemoryBackend;
+
+/** Codec-backed key/value tier over a passive byte backend (D82). */
+interface KvStorageTier<T = unknown> {
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    putIfAbsent?(key: string, value: T): Promise<boolean>;
+    getVersioned?(key: string): Promise<KvVersionedRead<T>>;
+    setIfMatch?(key: string, value: T, generation: StorageGeneration): Promise<boolean>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string): Promise<readonly string[]>;
+}
+/** Typed D85 conditional-create capability over a KV tier. */
+interface PutIfAbsentKvStorageTier<T = unknown> extends KvStorageTier<T> {
+    putIfAbsent(key: string, value: T): Promise<boolean>;
+}
+/** Opaque D108 per-key generation token for typed KV versioned reads. */
+type KvGeneration = StorageGeneration;
+/** D108 versioned typed read result with explicit present/absent observations. */
+type KvVersionedRead<T> = {
+    readonly kind: "hit";
+    readonly value: T;
+    readonly generation: KvGeneration;
+} | {
+    readonly kind: "miss";
+    readonly generation: KvGeneration;
+};
+/** Typed D108 versioned read + generation-conditional set capability over a KV tier. */
+interface VersionedKvStorageTier<T = unknown> extends KvStorageTier<T> {
+    getVersioned(key: string): Promise<KvVersionedRead<T>>;
+    setIfMatch(key: string, value: T, generation: KvGeneration): Promise<boolean>;
+}
+/** Runtime guard for typed KV tiers that expose D85 conditional create. */
+declare function hasKvPutIfAbsent<T>(tier: KvStorageTier<T>): tier is PutIfAbsentKvStorageTier<T>;
+/** Require D85 conditional-create support and produce a clear adapter error when absent. */
+declare function requireKvPutIfAbsent<T>(tier: KvStorageTier<T>, label?: string): PutIfAbsentKvStorageTier<T>;
+/** Runtime guard for typed KV tiers that expose D108 versioned read/set-if-match. */
+declare function hasKvVersioned<T>(tier: KvStorageTier<T>): tier is VersionedKvStorageTier<T>;
+/** Require D108 versioned KV support and produce a clear adapter error when absent. */
+declare function requireKvVersioned<T>(tier: KvStorageTier<T>, label?: string): VersionedKvStorageTier<T>;
+/** Options for wrapping a byte backend as a typed KV tier. */
+interface KvStorageOptions<T> {
+    backend: StorageBackend;
+    codec?: Codec<T>;
+}
+/** Build a typed KV tier from a byte backend and codec. */
+declare function kvStorage<T = unknown>(opts: KvStorageOptions<T>): KvStorageTier<T>;
+/** Create an in-memory typed KV tier. */
+declare function memoryKv<T = unknown>(codec?: Codec<T>): KvStorageTier<T>;
+/** Create an in-memory typed KV tier preloaded from a record. */
+declare function dictKv<T = unknown>(entries?: Record<string, T>, codec?: Codec<T>): KvStorageTier<T>;
+/** Convenience wrapper for deterministic prefix listing. */
+declare function listByPrefix<T>(tier: KvStorageTier<T>, prefix?: string): Promise<readonly string[]>;
+
+declare const APPEND_LOG_SEQ_PAD = 20;
+/** One append-log record with its storage key and monotonic sequence. */
+interface AppendLogEntry<T> {
+    readonly key: string;
+    readonly seq: number;
+    readonly value: T;
+}
+/** Cursor and page-size options for append-log reads. */
+interface AppendLogReadOptions {
+    /** Return entries with seq > after. */
+    after?: number;
+    limit?: number;
+}
+/** One bounded append-log page with the cursor for the next read. */
+interface AppendLogPage<T> {
+    readonly entries: readonly AppendLogEntry<T>[];
+    readonly nextAfter: number;
+    readonly done: boolean;
+}
+/**
+ * Append-only tier for durable event/change logs (D82), not graph restore replay.
+ *
+ * This first-cut helper serializes operations within one handle. Concurrent writers sharing the
+ * same KV prefix need an external single-writer discipline or a future CAS-capable backend.
+ */
+interface AppendLogStorageTier<T = unknown> {
+    append(value: T): Promise<AppendLogEntry<T>>;
+    read(opts?: AppendLogReadOptions): Promise<readonly AppendLogEntry<T>[]>;
+    truncateAfter(seq: number): Promise<void>;
+    size(): Promise<number>;
+}
+/** D85 multi-writer append log; requires a passive conditional-create KV capability. */
+type MultiWriterAppendLogStorageTier<T = unknown> = AppendLogStorageTier<T>;
+/** Build the deterministic storage key for an append-log sequence number. */
+declare function appendLogKey(prefix: string, seq: number): string;
+/** Read one ordered append-log page without assigning replay or restore semantics. */
+declare function readAppendLogPage<T>(log: AppendLogStorageTier<T>, opts?: AppendLogReadOptions): Promise<AppendLogPage<T>>;
+/** Options for a typed append log over a KV tier. */
+interface AppendLogOptions<T> {
+    kv: KvStorageTier<T>;
+    prefix?: string;
+}
+/** Options for D85 multi-writer append logs over conditional-create capable KV. */
+interface MultiWriterAppendLogOptions<T> extends AppendLogOptions<T> {
+    /** Bound retry work before refreshing the listed tail after another writer wins slots. */
+    maxAttempts?: number;
+}
+/**
+ * Build a single-writer append-only log over a KV tier, serializing all operations in call order
+ * for this handle. D85 multi-handle concurrent appends require multiWriterAppendLogStorage.
+ */
+declare function appendLogStorage<T = unknown>(opts: AppendLogOptions<T>): AppendLogStorageTier<T>;
+/**
+ * Build a D85 multi-writer append log over a conditional-create capable KV tier.
+ *
+ * Sequence allocation is passive storage work: each writer proposes a padded key and retries the
+ * next key when another writer already created that slot. This does not provide general CAS,
+ * locks, leases, transactions, unsafe truncation, WAL replay, or graph restore semantics.
+ */
+declare function multiWriterAppendLogStorage<T = unknown>(opts: MultiWriterAppendLogOptions<T>): MultiWriterAppendLogStorageTier<T>;
+/** Create an in-memory append log. */
+declare function memoryAppendLog<T = unknown>(prefix?: string): AppendLogStorageTier<T>;
+/** Create an in-memory D85 multi-writer append log. */
+declare function memoryMultiWriterAppendLog<T = unknown>(prefix?: string): MultiWriterAppendLogStorageTier<T>;
+
+export { APPEND_LOG_SEQ_PAD as A, memoryMultiWriterAppendLog as B, multiWriterAppendLogStorage as C, readAppendLogPage as D, requireKvPutIfAbsent as E, requireKvVersioned as F, requireStoragePutIfAbsent as G, requireStorageVersioned as H, webStorageBackend as I, type KvGeneration as K, type MemoryBackend as M, type PutIfAbsentKvStorageTier as P, type StorageBackend as S, type VersionedKvStorageTier as V, type WebStorageLike as W, type AppendLogEntry as a, type AppendLogPage as b, type AppendLogReadOptions as c, type AppendLogStorageTier as d, type KvStorageOptions as e, type KvStorageTier as f, type KvVersionedRead as g, type MultiWriterAppendLogOptions as h, type MultiWriterAppendLogStorageTier as i, type PutIfAbsentStorageBackend as j, type StorageGeneration as k, type StorageNamespaceOptions as l, type StorageVersionedRead as m, type VersionedStorageBackend as n, appendLogKey as o, appendLogStorage as p, dictKv as q, hasKvPutIfAbsent as r, hasKvVersioned as s, hasStoragePutIfAbsent as t, hasStorageVersioned as u, kvStorage as v, listByPrefix as w, memoryAppendLog as x, memoryBackend as y, memoryKv as z };

package/dist/append-log-DzKMmjxx.d.ts

@@ -0,0 +1,189 @@
+import { C as Codec } from './codec-BB7p8fJc.js';
+
+/**
+ * Byte storage backends (D82): passive adapter-owned storage, no graph methods.
+ */
+/** Passive byte-addressed backend used by D82 storage binding tiers. */
+interface StorageBackend {
+    get(key: string): undefined | Uint8Array | PromiseLike<undefined | Uint8Array>;
+    put(key: string, value: Uint8Array): void | PromiseLike<void>;
+    putIfAbsent?(key: string, value: Uint8Array): boolean | PromiseLike<boolean>;
+    getVersioned?(key: string): StorageVersionedRead | PromiseLike<StorageVersionedRead>;
+    setIfMatch?(key: string, value: Uint8Array, generation: StorageGeneration): boolean | PromiseLike<boolean>;
+    delete?(key: string): void | PromiseLike<void>;
+    list?(prefix?: string): readonly string[] | PromiseLike<readonly string[]>;
+}
+/** Passive D85 conditional-create capability for multi-writer storage helpers. */
+interface PutIfAbsentStorageBackend extends StorageBackend {
+    putIfAbsent(key: string, value: Uint8Array): boolean | PromiseLike<boolean>;
+}
+/** Opaque D108 per-key generation token for passive storage versioned reads. */
+type StorageGeneration = unknown;
+/** D108 versioned byte read result with explicit present/absent observations. */
+type StorageVersionedRead = {
+    readonly kind: "hit";
+    readonly value: Uint8Array;
+    readonly generation: StorageGeneration;
+} | {
+    readonly kind: "miss";
+    readonly generation: StorageGeneration;
+};
+/** Passive D108 versioned read + generation-conditional set capability. */
+interface VersionedStorageBackend extends StorageBackend {
+    getVersioned(key: string): StorageVersionedRead | PromiseLike<StorageVersionedRead>;
+    setIfMatch(key: string, value: Uint8Array, generation: StorageGeneration): boolean | PromiseLike<boolean>;
+}
+/** Runtime guard for D85 conditional-create capable byte backends. */
+declare function hasStoragePutIfAbsent(backend: StorageBackend): backend is PutIfAbsentStorageBackend;
+/** Require D85 conditional-create support and produce a clear adapter error when absent. */
+declare function requireStoragePutIfAbsent(backend: StorageBackend, label?: string): PutIfAbsentStorageBackend;
+/** Runtime guard for D108 versioned byte backends. */
+declare function hasStorageVersioned(backend: StorageBackend): backend is VersionedStorageBackend;
+/** Require D108 versioned support and produce a clear adapter error when absent. */
+declare function requireStorageVersioned(backend: StorageBackend, label?: string): VersionedStorageBackend;
+/** Browser/storage-adapter shape for deterministic byte helpers (DOM-free for portability). */
+interface WebStorageLike {
+    readonly length?: number;
+    getItem(key: string): string | null | undefined;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    key?(index: number): string | null | undefined;
+    keys?(): readonly string[];
+}
+/** Storage helper options for namespace isolation and logical-key prefixing. */
+interface StorageNamespaceOptions {
+    /**
+     * Optional namespace for logical keys.
+     *
+     * Namespace is part of key mapping only and is not returned from `list()`.
+     */
+    namespace?: string;
+}
+/** Build a deterministic byte backend backed by a browser-like key/value store (D103/D82). */
+declare function webStorageBackend(storage: WebStorageLike, opts?: StorageNamespaceOptions): StorageBackend;
+/** In-memory backend for tests, adapters, and lightweight local storage. */
+interface MemoryBackend extends StorageBackend {
+    readonly entries: ReadonlyMap<string, Uint8Array>;
+    clear(): void;
+}
+/** Create a byte-cloning in-memory backend. */
+declare function memoryBackend(initial?: Iterable<readonly [string, Uint8Array]>): MemoryBackend;
+
+/** Codec-backed key/value tier over a passive byte backend (D82). */
+interface KvStorageTier<T = unknown> {
+    get(key: string): Promise<T | undefined>;
+    set(key: string, value: T): Promise<void>;
+    putIfAbsent?(key: string, value: T): Promise<boolean>;
+    getVersioned?(key: string): Promise<KvVersionedRead<T>>;
+    setIfMatch?(key: string, value: T, generation: StorageGeneration): Promise<boolean>;
+    delete(key: string): Promise<void>;
+    list(prefix?: string): Promise<readonly string[]>;
+}
+/** Typed D85 conditional-create capability over a KV tier. */
+interface PutIfAbsentKvStorageTier<T = unknown> extends KvStorageTier<T> {
+    putIfAbsent(key: string, value: T): Promise<boolean>;
+}
+/** Opaque D108 per-key generation token for typed KV versioned reads. */
+type KvGeneration = StorageGeneration;
+/** D108 versioned typed read result with explicit present/absent observations. */
+type KvVersionedRead<T> = {
+    readonly kind: "hit";
+    readonly value: T;
+    readonly generation: KvGeneration;
+} | {
+    readonly kind: "miss";
+    readonly generation: KvGeneration;
+};
+/** Typed D108 versioned read + generation-conditional set capability over a KV tier. */
+interface VersionedKvStorageTier<T = unknown> extends KvStorageTier<T> {
+    getVersioned(key: string): Promise<KvVersionedRead<T>>;
+    setIfMatch(key: string, value: T, generation: KvGeneration): Promise<boolean>;
+}
+/** Runtime guard for typed KV tiers that expose D85 conditional create. */
+declare function hasKvPutIfAbsent<T>(tier: KvStorageTier<T>): tier is PutIfAbsentKvStorageTier<T>;
+/** Require D85 conditional-create support and produce a clear adapter error when absent. */
+declare function requireKvPutIfAbsent<T>(tier: KvStorageTier<T>, label?: string): PutIfAbsentKvStorageTier<T>;
+/** Runtime guard for typed KV tiers that expose D108 versioned read/set-if-match. */
+declare function hasKvVersioned<T>(tier: KvStorageTier<T>): tier is VersionedKvStorageTier<T>;
+/** Require D108 versioned KV support and produce a clear adapter error when absent. */
+declare function requireKvVersioned<T>(tier: KvStorageTier<T>, label?: string): VersionedKvStorageTier<T>;
+/** Options for wrapping a byte backend as a typed KV tier. */
+interface KvStorageOptions<T> {
+    backend: StorageBackend;
+    codec?: Codec<T>;
+}
+/** Build a typed KV tier from a byte backend and codec. */
+declare function kvStorage<T = unknown>(opts: KvStorageOptions<T>): KvStorageTier<T>;
+/** Create an in-memory typed KV tier. */
+declare function memoryKv<T = unknown>(codec?: Codec<T>): KvStorageTier<T>;
+/** Create an in-memory typed KV tier preloaded from a record. */
+declare function dictKv<T = unknown>(entries?: Record<string, T>, codec?: Codec<T>): KvStorageTier<T>;
+/** Convenience wrapper for deterministic prefix listing. */
+declare function listByPrefix<T>(tier: KvStorageTier<T>, prefix?: string): Promise<readonly string[]>;
+
+declare const APPEND_LOG_SEQ_PAD = 20;
+/** One append-log record with its storage key and monotonic sequence. */
+interface AppendLogEntry<T> {
+    readonly key: string;
+    readonly seq: number;
+    readonly value: T;
+}
+/** Cursor and page-size options for append-log reads. */
+interface AppendLogReadOptions {
+    /** Return entries with seq > after. */
+    after?: number;
+    limit?: number;
+}
+/** One bounded append-log page with the cursor for the next read. */
+interface AppendLogPage<T> {
+    readonly entries: readonly AppendLogEntry<T>[];
+    readonly nextAfter: number;
+    readonly done: boolean;
+}
+/**
+ * Append-only tier for durable event/change logs (D82), not graph restore replay.
+ *
+ * This first-cut helper serializes operations within one handle. Concurrent writers sharing the
+ * same KV prefix need an external single-writer discipline or a future CAS-capable backend.
+ */
+interface AppendLogStorageTier<T = unknown> {
+    append(value: T): Promise<AppendLogEntry<T>>;
+    read(opts?: AppendLogReadOptions): Promise<readonly AppendLogEntry<T>[]>;
+    truncateAfter(seq: number): Promise<void>;
+    size(): Promise<number>;
+}
+/** D85 multi-writer append log; requires a passive conditional-create KV capability. */
+type MultiWriterAppendLogStorageTier<T = unknown> = AppendLogStorageTier<T>;
+/** Build the deterministic storage key for an append-log sequence number. */
+declare function appendLogKey(prefix: string, seq: number): string;
+/** Read one ordered append-log page without assigning replay or restore semantics. */
+declare function readAppendLogPage<T>(log: AppendLogStorageTier<T>, opts?: AppendLogReadOptions): Promise<AppendLogPage<T>>;
+/** Options for a typed append log over a KV tier. */
+interface AppendLogOptions<T> {
+    kv: KvStorageTier<T>;
+    prefix?: string;
+}
+/** Options for D85 multi-writer append logs over conditional-create capable KV. */
+interface MultiWriterAppendLogOptions<T> extends AppendLogOptions<T> {
+    /** Bound retry work before refreshing the listed tail after another writer wins slots. */
+    maxAttempts?: number;
+}
+/**
+ * Build a single-writer append-only log over a KV tier, serializing all operations in call order
+ * for this handle. D85 multi-handle concurrent appends require multiWriterAppendLogStorage.
+ */
+declare function appendLogStorage<T = unknown>(opts: AppendLogOptions<T>): AppendLogStorageTier<T>;
+/**
+ * Build a D85 multi-writer append log over a conditional-create capable KV tier.
+ *
+ * Sequence allocation is passive storage work: each writer proposes a padded key and retries the
+ * next key when another writer already created that slot. This does not provide general CAS,
+ * locks, leases, transactions, unsafe truncation, WAL replay, or graph restore semantics.
+ */
+declare function multiWriterAppendLogStorage<T = unknown>(opts: MultiWriterAppendLogOptions<T>): MultiWriterAppendLogStorageTier<T>;
+/** Create an in-memory append log. */
+declare function memoryAppendLog<T = unknown>(prefix?: string): AppendLogStorageTier<T>;
+/** Create an in-memory D85 multi-writer append log. */
+declare function memoryMultiWriterAppendLog<T = unknown>(prefix?: string): MultiWriterAppendLogStorageTier<T>;
+
+export { APPEND_LOG_SEQ_PAD as A, memoryMultiWriterAppendLog as B, multiWriterAppendLogStorage as C, readAppendLogPage as D, requireKvPutIfAbsent as E, requireKvVersioned as F, requireStoragePutIfAbsent as G, requireStorageVersioned as H, webStorageBackend as I, type KvGeneration as K, type MemoryBackend as M, type PutIfAbsentKvStorageTier as P, type StorageBackend as S, type VersionedKvStorageTier as V, type WebStorageLike as W, type AppendLogEntry as a, type AppendLogPage as b, type AppendLogReadOptions as c, type AppendLogStorageTier as d, type KvStorageOptions as e, type KvStorageTier as f, type KvVersionedRead as g, type MultiWriterAppendLogOptions as h, type MultiWriterAppendLogStorageTier as i, type PutIfAbsentStorageBackend as j, type StorageGeneration as k, type StorageNamespaceOptions as l, type StorageVersionedRead as m, type VersionedStorageBackend as n, appendLogKey as o, appendLogStorage as p, dictKv as q, hasKvPutIfAbsent as r, hasKvVersioned as s, hasStoragePutIfAbsent as t, hasStorageVersioned as u, kvStorage as v, listByPrefix as w, memoryAppendLog as x, memoryBackend as y, memoryKv as z };