@jini-ai/vibecoding 0.6.10 → 0.6.11

package/dist/node/store.js

@@ -0,0 +1,478 @@
+import * as fs from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { withFileLock, writeFileAtomicAsync, writeJsonFileAtomicAsync } from '@jini-ai/platform/fs';
+import { ProjectError } from '../core/project.js';
+import { assertCandidatePaths, portablePathKey } from './paths.js';
+function fingerprint(info) {
+    return { size: info.size, mtimeMs: info.mtimeMs, ctimeMs: info.ctimeMs };
+}
+function sameFingerprint(left, right) {
+    return left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+/** Parents of removed managed files, deepest paths pruned first by callers. */
+function removedFolders({ before, after }) {
+    const kept = new Set(after.files.map(file => file.path)), folders = new Set();
+    for (const file of before.files) {
+        if (kept.has(file.path))
+            continue;
+        for (let folder = dirname(file.path); folder !== '.'; folder = dirname(folder))
+            folders.add(folder);
+    }
+    return folders;
+}
+const HASH = /^[a-f0-9]{64}$/;
+/** Immutable object/revision IDs are SHA-256 of their exact bytes. */
+export function digest({ bytes }, _options = {}) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+function inside(base, target) {
+    const child = relative(base, target);
+    return child === '' || (!child.startsWith(`..${sep}`) && child !== '..' && !isAbsolute(child));
+}
+function corrupt(message) { throw new ProjectError({ code: 'CORRUPT', message }); }
+function assertHash(hash) { if (!HASH.test(hash))
+    corrupt('invalid content identifier'); }
+function missing(error) { return error?.code === 'ENOENT'; }
+/** Absent destinations (or a file where a parent folder was expected) are not errors here. */
+async function lstatIfPresent(path) {
+    return fs.lstat(path).catch(error => { if (missing(error) || error.code === 'ENOTDIR')
+        return undefined; throw error; });
+}
+async function statIfPresent(path) {
+    return fs.stat(path).catch(error => { if (missing(error))
+        return undefined; throw error; });
+}
+/** Reject links and special files even when platform containment permits an in-root alias.
+ * Host owns the directory; this recheck is not a sandbox against hostile local processes.
+ * @complexity O(depth²) bounded containment probes and O(path length) space.
+ */
+async function regularPath({ paths, path }) {
+    const absolute = paths.reader.resolve({ relativePath: path });
+    const segments = path.split('/');
+    for (let end = 1; end <= segments.length; end += 1) {
+        const probe = paths.reader.resolve({ relativePath: segments.slice(0, end).join('/') });
+        const info = await lstatIfPresent(probe);
+        if (!info)
+            continue;
+        if (info.isSymbolicLink() || (!info.isDirectory() && !info.isFile())) {
+            throw new ProjectError({ code: 'INVALID_PATH', message: `link or special file refused: ${path}` });
+        }
+    }
+    return absolute;
+}
+/** Bounded metadata read; malformed JSON is corruption, never a cue to reset a project. */
+async function readJson({ path, maxBytes }) {
+    const handle = await fs.open(path, 'r');
+    try {
+        const bytes = await readBounded({ handle, maxBytes });
+        if (bytes.byteLength > maxBytes)
+            corrupt('metadata exceeds project limits');
+        try {
+            return JSON.parse(bytes.toString('utf8'));
+        }
+        catch (cause) {
+            throw new ProjectError({ code: 'CORRUPT', message: 'invalid project metadata JSON', cause });
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Read at most maxBytes + 1 so an oversized file is detected without an unbounded buffer. */
+async function readBounded({ handle, maxBytes }) {
+    const bytes = Buffer.alloc(maxBytes + 1);
+    let count = 0;
+    while (count < bytes.length) {
+        const result = await handle.read(bytes, count, bytes.length - count, null);
+        if (!result.bytesRead)
+            break;
+        count += result.bytesRead;
+    }
+    return bytes.subarray(0, count);
+}
+/** Validate manifest structure, portable names, policy and aggregate bounds before any I/O. */
+function checkManifest({ value, paths, limits }) {
+    const manifest = value;
+    if (manifest?.version !== 1 || !Array.isArray(manifest.files))
+        corrupt('unsupported manifest');
+    if (manifest.files.length > limits.maxFiles)
+        corrupt('manifest exceeds file limit');
+    let bytes = 0;
+    const seen = new Set();
+    for (const file of manifest.files) {
+        checkManifestFile({ file, paths, limits });
+        if (seen.has(file.path))
+            corrupt('duplicate manifest path');
+        seen.add(file.path);
+        bytes += file.size;
+    }
+    if (bytes > limits.maxTreeBytes)
+        corrupt('manifest exceeds tree limit');
+    assertCandidatePaths({ paths: [...seen] });
+    return manifest;
+}
+function checkManifestFile({ file, paths, limits }) {
+    if (!file || typeof file.path !== 'string' || typeof file.hash !== 'string')
+        corrupt('invalid manifest file');
+    assertHash(file.hash);
+    paths.check({ relativePath: file.path });
+    if (!Number.isSafeInteger(file.size) || file.size < 0 || file.size > limits.maxFileBytes)
+        corrupt('invalid manifest size');
+}
+function checkCurrent({ value, root }) {
+    const current = value;
+    if (current?.version !== 1 || current.root !== root)
+        corrupt('stateDir belongs to another root or schema');
+    assertHash(current.revision);
+    if (!Number.isSafeInteger(current.generation) || current.generation < 1)
+        corrupt('invalid generation');
+    checkPending(current.pending);
+    checkObserved(current.observed);
+    return current;
+}
+function checkObserved(observed) {
+    if (!observed || typeof observed !== 'object' || Array.isArray(observed))
+        corrupt('invalid observed file metadata');
+    for (const value of Object.values(observed))
+        checkFingerprint(value);
+}
+function checkFingerprint(value) {
+    if (!value || typeof value !== 'object')
+        corrupt('invalid file fingerprint');
+    if (!Number.isSafeInteger(value.size) || value.size < 0)
+        corrupt('invalid fingerprint size');
+    if (!Number.isFinite(value.mtimeMs) || !Number.isFinite(value.ctimeMs))
+        corrupt('invalid fingerprint timestamps');
+}
+function checkPending(pending) {
+    if (pending === null)
+        return;
+    if (typeof pending !== 'object' || !pending || !('from' in pending))
+        corrupt('invalid pending journal');
+    if (pending.from !== null)
+        assertHash(pending.from);
+}
+/** Host state is physically separate from the watched/served tree, in both directions.
+ * @throws ProjectError INVALID_PATH when either canonical directory contains the other.
+ * @complexity O(path length) plus constant directory I/O.
+ */
+export async function prepareDirectories({ root, stateDir }, _options = {}) {
+    await fs.mkdir(root, { recursive: true });
+    await fs.mkdir(stateDir, { recursive: true, mode: 0o700 });
+    const canonicalRoot = await fs.realpath(root), canonicalState = await fs.realpath(stateDir);
+    if (inside(canonicalRoot, canonicalState) || inside(canonicalState, canonicalRoot)) {
+        throw new ProjectError({ code: 'INVALID_PATH', message: 'stateDir must be outside and separate from the app root' });
+    }
+    return { root: canonicalRoot, stateDir: canonicalState };
+}
+/** Content-addressed persistence and idempotent roll-forward. Call mutations inside locked().
+ * @complexity O(bytes + files log files + files × depth²) for capture; memory bounded by maxTreeBytes.
+ */
+export function createProjectStore({ root, stateDir, paths, limits }, options = {}) {
+    const currentPath = resolve(stateDir, 'current.json');
+    const objectPath = (hash) => { assertHash(hash); return resolve(stateDir, 'objects', hash); };
+    const manifestPath = (hash) => { assertHash(hash); return resolve(stateDir, 'manifests', `${hash}.json`); };
+    const checkpoint = async (step) => { await options.checkpoint?.({ step }); };
+    const metadataLimit = limits.maxFiles * 1024 + 4096;
+    async function readCurrent() {
+        const value = await readJson({ path: currentPath, maxBytes: metadataLimit }).catch(error => {
+            if (missing(error))
+                return undefined;
+            throw error;
+        });
+        return value === undefined ? null : checkCurrent({ value, root });
+    }
+    async function manifest({ revisionId }) {
+        const value = await readJson({ path: manifestPath(revisionId), maxBytes: metadataLimit });
+        const result = checkManifest({ value, paths, limits });
+        if (digest({ bytes: JSON.stringify(result) }) !== revisionId)
+            corrupt('manifest digest mismatch');
+        return result;
+    }
+    async function object({ file }) {
+        const handle = await fs.open(objectPath(file.hash), 'r').catch(cause => {
+            if (missing(cause))
+                throw new ProjectError({ code: 'CORRUPT', message: 'referenced object is missing', cause });
+            throw cause;
+        });
+        try {
+            const content = await readBounded({ handle, maxBytes: file.size });
+            if (content.byteLength !== file.size || digest({ bytes: content }) !== file.hash)
+                corrupt('object digest/size mismatch');
+            return content;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    /** Prepare every durable dependency before publishing a pending selection. */
+    async function prepare({ files }) {
+        assertCandidatePaths({ paths: [...files.keys()] });
+        const entries = [];
+        for (const [path, bytes] of [...files].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+            const file = { path, hash: digest({ bytes }), size: bytes.byteLength };
+            entries.push(file);
+        }
+        const value = checkManifest({ value: { version: 1, files: entries }, paths, limits });
+        for (const file of entries)
+            await writeObject({ file, bytes: files.get(file.path) });
+        await checkpoint('objects');
+        const revisionId = digest({ bytes: JSON.stringify(value) });
+        const existing = await statIfPresent(manifestPath(revisionId));
+        if (existing)
+            await manifest({ revisionId });
+        else
+            await writeJsonFileAtomicAsync({ filePath: manifestPath(revisionId), data: value }, { createParent: true });
+        await checkpoint('manifest');
+        return revisionId;
+    }
+    async function writeObject({ file, bytes }) {
+        const exists = await statIfPresent(objectPath(file.hash));
+        if (exists)
+            await object({ file });
+        else
+            await writeFileAtomicAsync({ filePath: objectPath(file.hash), content: bytes }, { createParent: true });
+    }
+    async function observations({ files }) {
+        const result = Object.create(null);
+        for (const file of files) {
+            const absolute = await regularPath({ paths, path: file.path });
+            const info = await fs.stat(absolute);
+            const bytes = await paths.reader.readBytes({ relativePath: file.path, maxBytes: limits.maxFileBytes });
+            const after = await fs.stat(absolute);
+            // A watcher may rewrite a file immediately after a rename. Do not cache its new timestamp
+            // against old object bytes: leaving it unobserved makes the next capture hash the drift.
+            if (sameFingerprint(info, after) && digest({ bytes }) === file.hash)
+                result[file.path] = fingerprint(info);
+        }
+        return result;
+    }
+    /** Capture hashes only files whose disk fingerprint changed; unchanged bytes reuse objects. */
+    async function scan({ current }) {
+        const listed = paths.reader.list({});
+        if (listed.truncated)
+            throw new ProjectError({ code: 'LIMIT', message: 'tree traversal exceeded limits' });
+        // Host-disallowed files remain unmanaged; malformed allowed names are refused rather than hidden.
+        const names = listed.files.filter(relativePath => paths.allows({ relativePath }));
+        assertCandidatePaths({ paths: names });
+        const base = current ? await manifest({ revisionId: current.revision }) : { files: [] };
+        const previous = new Map(base.files.map(file => [file.path, file]));
+        const files = new Map();
+        let total = 0;
+        const observed = Object.create(null);
+        for (const path of names) {
+            const scanned = await scanFile({ path, previous: previous.get(path), observed: current?.observed[path] });
+            total += scanned.bytes.byteLength;
+            if (total > limits.maxTreeBytes || files.size >= limits.maxFiles)
+                throw new ProjectError({ code: 'LIMIT', message: 'tree exceeds project limits' });
+            files.set(path, scanned.bytes);
+            observed[path] = scanned.observed;
+        }
+        return { files, observed };
+    }
+    async function scanFile({ path, previous, observed }) {
+        paths.check({ relativePath: path });
+        const absolute = await regularPath({ paths, path });
+        const info = await fs.stat(absolute);
+        const bytes = previous && observed && sameFingerprint(info, observed)
+            ? await object({ file: previous })
+            : await paths.reader.readBytes({ relativePath: path, maxBytes: limits.maxFileBytes });
+        const after = await fs.stat(absolute);
+        if (!sameFingerprint(info, after))
+            throw new ProjectError({ code: 'CONFLICT', message: `file changed while capturing: ${path}` });
+        return { bytes, observed: fingerprint(info) };
+    }
+    /** Read a published live file without scanning/re-hashing the whole project for every viewer read. */
+    async function readWorkingFile({ relativePath }) {
+        await regularPath({ paths, path: relativePath });
+        return paths.reader.readBytes({ relativePath, maxBytes: limits.maxFileBytes });
+    }
+    async function removeManaged({ before, after }) {
+        const retained = new Set(after.files.map(file => file.path));
+        for (const file of before.files) {
+            if (retained.has(file.path))
+                continue;
+            try {
+                await fs.rm(await regularPath({ paths, path: file.path }), { force: true });
+            }
+            catch (error) {
+                if (!['ENOENT', 'ENOTDIR'].includes(error.code ?? ''))
+                    throw error;
+            }
+            await checkpoint('delete');
+        }
+    }
+    /** Prune only directories that contained a removed managed file; never recurse into exclusions. */
+    async function prune({ before, after }) {
+        const folders = removedFolders({ before, after });
+        for (const folder of [...folders].sort((a, b) => b.split('/').length - a.split('/').length)) {
+            await pruneFolder({ folder });
+        }
+        await checkpoint('prune');
+    }
+    async function pruneFolder({ folder }) {
+        try {
+            await fs.rmdir(await regularPath({ paths, path: folder }));
+        }
+        catch (error) {
+            if (!['ENOENT', 'ENOTEMPTY', 'EEXIST', 'ENOTDIR'].includes(error.code ?? ''))
+                throw error;
+        }
+    }
+    /** On case-insensitive volumes, reusing an empty old directory preserves its old spelling.
+     * Remove only empty managed aliases before writes, so a case-only directory rename is real.
+     */
+    async function pruneRenamedFolders({ before, after }) {
+        const previous = removedFolders({ before, after: { version: 1, files: [] } });
+        const next = removedFolders({ before: after, after: { version: 1, files: [] } });
+        const aliases = new Map([...next].map(folder => [portablePathKey({ path: folder }), folder]));
+        for (const folder of [...previous].sort((a, b) => b.length - a.length)) {
+            const alias = aliases.get(portablePathKey({ path: folder }));
+            if (alias !== undefined && alias !== folder)
+                await pruneFolder({ folder });
+        }
+    }
+    /** Pre-read/verify every object before the first deletion. Pending remains until all writes land. */
+    async function materialize({ current }) {
+        const after = await manifest({ revisionId: current.revision });
+        const before = current.pending?.from ? await manifest({ revisionId: current.pending.from }) : { version: 1, files: [] };
+        const previous = new Map(before.files.map(file => [file.path, file.hash]));
+        const writes = after.files.filter(file => previous.get(file.path) !== file.hash);
+        const bytes = new Map();
+        for (const file of after.files)
+            bytes.set(file.path, await object({ file }));
+        await removeManaged({ before, after });
+        await pruneRenamedFolders({ before, after });
+        // Empty folders blocking a directory-to-file transition must be removed before writing it.
+        for (const file of writes)
+            await removeBlockingFolder({ path: file.path, before });
+        for (const file of writes) {
+            await writeFileAtomicAsync({ filePath: await regularPath({ paths, path: file.path }), content: bytes.get(file.path) }, { createParent: true, refuseSymlink: true, defaultMode: 0o644 });
+            await checkpoint('write');
+        }
+        await prune({ before, after });
+        const settled = { ...current, pending: null, observed: await observations(after) };
+        await writeJsonFileAtomicAsync({ filePath: currentPath, data: settled });
+        await checkpoint('clear');
+        return settled;
+    }
+    async function removeBlockingFolder({ path, before }) {
+        const destination = await regularPath({ paths, path });
+        const info = await lstatIfPresent(destination);
+        if (!info?.isDirectory())
+            return;
+        const folders = removedFolders({ before, after: { version: 1, files: [] } });
+        for (const folder of [...folders].sort((a, b) => b.length - a.length)) {
+            if (folder.startsWith(`${path}/`))
+                await pruneFolder({ folder });
+        }
+        await fs.rmdir(destination);
+    }
+    /** Refuse unsafe/unmanaged obstructions before the journal commit point. */
+    async function preflight({ current, revisionId }) {
+        const after = await manifest({ revisionId });
+        const before = current ? await manifest({ revisionId: current.revision }) : { version: 1, files: [] };
+        const folders = removedFolders({ before, after });
+        const kept = new Set(after.files.map(file => file.path));
+        const removed = new Set(before.files.filter(file => !kept.has(file.path)).map(file => file.path));
+        const sources = new Map(before.files.map(file => [portablePathKey({ path: file.path }), file.path]));
+        await assertRenamedFolders({ before, after, folders, removed });
+        for (const file of after.files) {
+            await object({ file });
+            const target = await regularPath({ paths, path: file.path });
+            const info = await lstatIfPresent(target);
+            assertManagedDestination({ existsAsFile: info?.isFile() ?? false, path: file.path, sources });
+            if (info?.isDirectory())
+                await assertRemovableFolder({ path: file.path, folders, removed });
+        }
+    }
+    /** An existing filesystem alias must not let a create overwrite a host-disallowed file. */
+    function assertManagedDestination({ existsAsFile, path, sources }) {
+        if (!existsAsFile || sources.has(portablePathKey({ path })))
+            return;
+        throw new ProjectError({ code: 'INVALID_CHANGE', message: `unmanaged file blocks ${path}` });
+    }
+    /** A portable case rename cannot silently retain an unmanaged directory under its old spelling. */
+    async function assertRenamedFolders({ before, after, folders, removed }) {
+        const previous = removedFolders({ before, after: { version: 1, files: [] } });
+        const next = removedFolders({ before: after, after: { version: 1, files: [] } });
+        const aliases = new Map([...next].map(folder => [portablePathKey({ path: folder }), folder]));
+        for (const path of previous) {
+            const alias = aliases.get(portablePathKey({ path }));
+            if (alias !== undefined && alias !== path)
+                await assertRemovableFolder({ path, folders, removed });
+        }
+    }
+    async function assertRemovableFolder({ path, folders, removed }) {
+        const inspect = new Set([path, ...[...folders].filter(folder => folder.startsWith(`${path}/`))]);
+        for (const folder of inspect) {
+            for (const name of await fs.readdir(await regularPath({ paths, path: folder }))) {
+                const child = `${folder}/${name}`;
+                if (!folders.has(child) && !removed.has(child))
+                    throw new ProjectError({ code: 'INVALID_CHANGE', message: `unmanaged directory contents block ${path}` });
+            }
+        }
+    }
+    async function recover() {
+        const current = await readCurrent();
+        if (!current)
+            return null;
+        try {
+            await manifest({ revisionId: current.revision });
+        }
+        catch (cause) {
+            if (missing(cause))
+                throw new ProjectError({ code: 'CORRUPT', message: 'current manifest is missing', cause });
+            throw cause;
+        }
+        return current.pending ? materialize({ current }) : current;
+    }
+    /** Journal is the commit point. Reopen rolls it forward; no rollback or guessed replacement. */
+    async function select({ current, revisionId, captured }) {
+        await manifest({ revisionId });
+        if (current?.generation === Number.MAX_SAFE_INTEGER)
+            throw new ProjectError({ code: 'LIMIT', message: 'generation exhausted' });
+        const next = { version: 1, root, revision: revisionId, generation: (current?.generation ?? 0) + 1,
+            pending: captured ? null : { from: current?.revision ?? null }, observed: captured ?? {} };
+        await writeJsonFileAtomicAsync({ filePath: currentPath, data: next });
+        await checkpoint('journal');
+        return captured ? next : materialize({ current: next });
+    }
+    /** Refresh a same-content capture's fingerprints without inventing a new revision/generation. */
+    async function observe({ current, observed }) {
+        if (JSON.stringify(current.observed) === JSON.stringify(observed))
+            return current;
+        const next = { ...current, observed };
+        await writeJsonFileAtomicAsync({ filePath: currentPath, data: next });
+        return next;
+    }
+    /** Both stacks pin manifests and blobs. Expired snapshots do not pin storage indefinitely. */
+    async function collect({ revisions }) {
+        const objects = new Set();
+        for (const revisionId of revisions) {
+            for (const file of (await manifest({ revisionId })).files)
+                objects.add(file.hash);
+        }
+        await removeUnreferenced({ directory: resolve(stateDir, 'manifests'), keep: new Set([...revisions].map(id => `${id}.json`)) });
+        await removeUnreferenced({ directory: resolve(stateDir, 'objects'), keep: objects });
+    }
+    return {
+        readCurrent, manifest, object, prepare, scan, select, collect, preflight, observe, readWorkingFile,
+        locked: (run) => withFileLock({ lockPath: resolve(stateDir, 'project.lock'), run }, { staleMs: Infinity, createParent: true }),
+        recover,
+    };
+}
+/** Generated orphan objects/manifests are safe to discard only while holding the project lock. */
+async function removeUnreferenced({ directory, keep }) {
+    const names = await fs.readdir(directory).catch(error => { if (missing(error))
+        return []; throw error; });
+    for (const name of names) {
+        if (!keep.has(name))
+            await fs.rm(resolve(directory, name), { force: true });
+    }
+}
+export function revisionToken({ current }, _options = {}) {
+    return { revisionId: current.revision, generation: current.generation };
+}
+//# sourceMappingURL=store.js.map

package/dist/react/session.d.ts

@@ -1,108 +1,3 @@
-/**
- * @module react/session
- *
- * `VibecodingSession` — the one stateful object this package's React layer adds on top of
- * `../core`'s `EditTarget` + `EditHistory`. Everything else in `./react` (the hook, the tool
- * registrations, the presentational components) reads and drives an artifact through this seam
- * rather than touching `EditTarget`/`EditHistory` directly, for one reason: a tool call arrives
- * from the chat's execution path, not from a React event handler, so the thing tool handlers call
- * into cannot be React state — it has to be a plain, subscribable object a `useSyncExternalStore`
- * hook can also read. This is the same shape React itself recommends for external stores; nothing
- * here is React-specific, but it lives under `./react` because "chat + preview surface" is exactly
- * what it exists to support (see this package's README's `./react` row).
- *
- * ## Why part content is cached rather than re-read on every render
- *
- * `EditTarget.readPart` is a host call — for the `html` target it is cheap (a string slice), but
- * the port makes no such promise for every target (a filesystem or sandbox-backed host could hit a
- * network round trip per part). Re-reading every listed part's content on every `refresh()` would
- * turn "the operator opened the file viewer" into an O(part count) fan-out of host calls, and
- * nothing here can assume that count stays small — see `../core/target.ts`'s own doc on why
- * `listParts` is the allowlist, not a bound on its size. So `refresh()` only calls `listParts()`;
- * content is fetched lazily, per id, through `readPart()`, and cached. Every mutating operation
- * below (`applyEdits`, `undo`, `redo`, `restoreSnapshot`) already knows the exact before/after
- * content it just wrote — `../core/apply.ts`'s `ProposedEdit`, `../core/history.ts`'s
- * `PartChange.before`/`.after` — so the cache is updated from that data directly instead of
- * re-reading the part it just wrote back from the host.
- */
-import type { ApplyOutcome, PartId, PartRef, Snapshot } from '../core/types.js';
-import type { EditTarget } from '../core/target.js';
-import { type ProposedEdit } from '../core/apply.js';
-import { type EditHistory, type EditHistoryOptions, type HistoryEntry } from '../core/history.js';
-export interface VibecodingSessionArgs {
-    /** The host's artifact port. See `../core/target.ts`. */
-    readonly target: EditTarget;
-}
-export interface VibecodingSessionOptions {
-    /** Forwarded to `createEditHistory`. See `../core/history.ts`'s `EditHistoryOptions`. */
-    readonly historyOptions?: EditHistoryOptions;
-}
-/**
- * Immutable, point-in-time read of a session. `getSnapshot()` returns the same object reference
- * until something actually changes — required for `useSyncExternalStore`, which re-renders a
- * subscriber whenever the reference it reads changes, not whenever it is merely called again.
- */
-export interface VibecodingSessionSnapshot {
-    /** `'idle'` until the first `refresh()` resolves; `'error'` reflects the most recent failure, not
-     *  a permanently wedged session — a subsequent successful call returns it to `'ready'`. */
-    readonly status: 'idle' | 'loading' | 'ready' | 'error';
-    /** Every part the host currently advertises, in `EditTarget.listParts()`'s own order. */
-    readonly parts: readonly PartRef[];
-    /** Cached content, keyed by part id. A part absent from this map has not been read yet — see
-     *  this module's doc for why content is lazy rather than eagerly fetched for every part. */
-    readonly partContent: ReadonlyMap<PartId, string>;
-    readonly canUndo: boolean;
-    readonly canRedo: boolean;
-    /** The most recent operation's failure message, if any. Cleared by the next successful call. */
-    readonly lastError: string | undefined;
-}
-export interface ApplyEditsResult {
-    readonly outcomes: readonly ApplyOutcome[];
-    /** See `../core/apply.ts`'s `correctionsFor` — the subset a caller feeds back to the model. */
-    readonly corrections: readonly {
-        readonly id: PartId;
-        readonly reason: string;
-    }[];
-}
-export interface VibecodingSession {
-    /** The underlying port, for a caller (or test) that needs it directly — e.g. to read the whole
-     *  document a host-specific target stores, which is outside this generic session's vocabulary. */
-    readonly target: EditTarget;
-    /** The underlying undo/redo stack, for a caller that needs `.entries()` for a history UI. */
-    readonly history: EditHistory;
-    getSnapshot(): VibecodingSessionSnapshot;
-    /** Returns an unsubscribe function; the React hook adapts this object API for React. */
-    subscribe(args: {
-        readonly listener: () => void;
-    }): () => void;
-    /** Re-lists parts from the host. Does not re-read content — see this module's doc. */
-    refresh(): Promise<void>;
-    /** Cached content for `id`, fetching once from the host on first request. */
-    readPart(args: {
-        readonly id: PartId;
-    }): Promise<string>;
-    /** Applies `edits` as one undoable transaction and updates the cache from the edits themselves. */
-    applyEdits(requiredArgs: {
-        readonly edits: readonly ProposedEdit[];
-    }, optionalArgs?: {
-        readonly label?: string;
-    }): Promise<ApplyEditsResult>;
-    undo(): Promise<HistoryEntry | null>;
-    redo(): Promise<HistoryEntry | null>;
-    takeSnapshot(): Promise<Snapshot>;
-    restoreSnapshot(args: {
-        readonly snapshot: Snapshot;
-    }): Promise<HistoryEntry | null>;
-}
-/**
- * Builds a session over the required `target` port, with its own private `EditHistory`.
- * History settings belong to the optional second object.
- *
- * The returned session starts in `'idle'` with no parts listed — call `refresh()` (or let
- * `useVibecodingSession` do it on mount) to populate it. Nothing here triggers I/O eagerly, so
- * constructing a session has no side effect a caller needs to clean up.
- *
- * @complexity Construction is O(1). See each method for its own cost.
- */
-export declare function createVibecodingSession({ target }: VibecodingSessionArgs, options?: VibecodingSessionOptions): VibecodingSession;
+/** Compatibility re-export; the implementation is framework-free. */
+export * from "../session.js";
 //# sourceMappingURL=session.d.ts.map