@anionex/dsh-turn-rewind 0.2.3 → 0.3.1

package/src/settings.ts

@@ -3,13 +3,25 @@
  * @module @anionex/dsh-turn-rewind
  */
 import type { Context } from '@deepseek-ai/cordis'
-import { installSettingsSection, settingsNamespace } from '@deepseek-ai/dsh-settings'
+// Type-only: loads the host's `Context.settings` augmentation and its provider
+// type without binding any runtime symbol (0.1.5 deleted `settingsNamespace`
+// and the free `installSettingsSection`, so a value import would break the whole
+// DSH web profile at load time).
+import type { SettingsProvider } from '@deepseek-ai/dsh-settings'
 import z from '@deepseek-ai/schemastery'
 import { resolveConfig, type ChangeLedgerEngine } from './engine.js'
 import type { ChangeLedgerConfig, ResolvedChangeLedgerConfig } from './types.js'
 
-/** Namespace join key shared by the host section and the browser settings card. */
-export const TURN_REWIND_SETTINGS_NAMESPACE = settingsNamespace('turn-rewind')
+/**
+ * Namespace join key shared by the host section and the browser settings card.
+ *
+ * DSH 0.1.5 removed the `settingsNamespace` helper and made `SettingsNamespace`
+ * a compile-time-only brand, so a plain lowercase literal is the entire runtime
+ * value — the upstream convention (`const CHAT_SETTINGS_NAMESPACE = 'ui-chat'`).
+ * The literal satisfies 0.1.5's registration grammar `/^[a-z][a-z0-9-]*$/` and is
+ * the exact key the browser card binds through `ctx.settingsScope.bind`.
+ */
+export const TURN_REWIND_SETTINGS_NAMESPACE = 'turn-rewind'
 
 /** Every runtime-tunable field of {@link ChangeLedgerConfig}; `storageDir` stays config-layer only. */
 export interface TurnRewindSettings {
@@ -72,15 +84,46 @@ function tunableSettings(resolved: ResolvedChangeLedgerConfig): TurnRewindSettin
   }
 }
 
+/** Owner scope handed back by {@link SettingsProviderLike.register}. */
+interface SettingsScopeLike<T> {
+  get(): T
+  watch(callback: (next: T, prev: T) => void | Promise<void>): () => void
+}
+
+/** Source sink and change notification a settings consumer hands to the provider. */
+interface SettingsSectionHooksLike<T> {
+  setSource(current: () => T): void
+  onChange(): void
+}
+
+/**
+ * Version-portable view of the parts of `ctx.settings` this plugin drives.
+ *
+ * The plugin spans DSH releases whose `@deepseek-ai/dsh-settings` type surface
+ * differs — 0.1.5 branded the namespace parameter and moved the consumer wiring
+ * onto the provider — so the wiring below is written against this structural view
+ * (namespace as a plain string) and intersected with the host's own
+ * {@link SettingsProvider} type at the single boundary where it is used.
+ */
+interface SettingsProviderLike {
+  register<T>(ns: string, schema: z<T>, options?: { readonly base?: Partial<T> }): SettingsScopeLike<T>
+  installSection?<T>(owner: Context, ns: string, schema: z<T>, entry: T, hooks: SettingsSectionHooksLike<T>): void
+}
+
 /**
  * Register the `turn-rewind` settings namespace and apply its resolved value to the
  * running engine. The composition entry (from `cordis.patch.yml`) is the base layer;
  * the user layer persists through the DSH settings provider. `storageDir` is never
  * carried by the namespace: the storage root must not move while the engine runs.
+ *
+ * `settings` is an optional service, so the whole wiring stays behind
+ * `ctx.inject(['settings'], …)`: a host without a provider keeps running on the
+ * composition entry alone.
  */
 export function installTurnRewindSettings(ctx: Context, config: ChangeLedgerConfig, engine: ChangeLedgerEngine): void {
-  let source: () => TurnRewindSettings = () => tunableSettings(resolveConfig(config))
-  installSettingsSection(ctx, TURN_REWIND_SETTINGS_NAMESPACE, TurnRewindSettingsSchema, source(), {
+  const entry = tunableSettings(resolveConfig(config))
+  let source: () => TurnRewindSettings = () => entry
+  const hooks: SettingsSectionHooksLike<TurnRewindSettings> = {
     setSource: (current) => { source = current },
     onChange: () => {
       try {
@@ -89,5 +132,30 @@ export function installTurnRewindSettings(ctx: Context, config: ChangeLedgerConf
         ctx.logger.warn(`[turn-rewind] could not apply settings update: ${error instanceof Error ? error.message : String(error)}`)
       }
     },
+  }
+  ctx.inject(['settings'], (scope: Context) => {
+    const provider = scope.settings as SettingsProvider & SettingsProviderLike
+    // 0.1.5 owns the canonical wiring on the provider itself; it also suppresses the
+    // detach fallback while the consumer is unloading, which the deleted free
+    // function did not do.
+    if (typeof provider.installSection === 'function') {
+      provider.installSection(ctx, TURN_REWIND_SETTINGS_NAMESPACE, TurnRewindSettingsSchema, entry, hooks)
+      return
+    }
+    // Older hosts shipped that wiring only as the free `installSettingsSection`,
+    // which 0.1.5 removed, so reproduce its body against `register` + `scope.get()`
+    // + `scope.watch()` — present in every supported version.
+    const settingsScope = provider.register(
+      TURN_REWIND_SETTINGS_NAMESPACE,
+      TurnRewindSettingsSchema,
+      { base: entry },
+    )
+    hooks.setSource(() => settingsScope.get())
+    scope.effect(() => () => {
+      hooks.setSource(() => entry)
+      hooks.onChange()
+    })
+    hooks.onChange()
+    settingsScope.watch(() => { hooks.onChange() })
   })
 }

package/src/snapshot.ts

@@ -2,9 +2,9 @@ import { createHash } from 'node:crypto'
 import { constants, type BigIntStats } from 'node:fs'
 import { lstat, open, readlink } from 'node:fs/promises'
 import { ChangeLedgerError } from './errors.js'
-import { discoverRepository, sameRepositoryFence, type RepositorySnapshotSource } from './git.js'
 import { isNodeError, resolveWorkspacePath } from './path-utils.js'
 import type { LedgerStore } from './store.js'
+import { discoverWorkspace, sameWorkspaceFence, type WorkspaceSnapshotSource } from './workspace.js'
 import type {
   ResolvedChangeLedgerConfig,
   SnapshotEntry,
@@ -15,7 +15,7 @@ const COMPARISON_READ_BUDGET_BYTES = 128 * 1024 * 1024
 
 /** One captured tree, optionally persisted into the blob store. */
 export interface CapturedTree {
-  readonly source: RepositorySnapshotSource
+  readonly source: WorkspaceSnapshotSource
   readonly entries: Readonly<Record<string, SnapshotEntry>>
   readonly gitEntries?: Readonly<Record<string, SnapshotEntry>>
   readonly treeHash: string
@@ -32,7 +32,7 @@ export async function captureTree(options: {
   readonly signal?: AbortSignal
 }): Promise<CapturedTree> {
   throwIfAborted(options.signal)
-  const source = await discoverRepository(options.cwd, options.signal)
+  const source = await discoverWorkspace(options.cwd, options.config, options.signal)
   if (source.paths.length > options.config.maxFiles) {
     throw new ChangeLedgerError(
       'TOO_MANY_FILES',
@@ -41,7 +41,9 @@ export async function captureTree(options: {
   }
 
   const entries: Record<string, SnapshotEntry> = Object.create(null) as Record<string, SnapshotEntry>
-  const gitObjectFormat = options.gitObjectFormat
+  // Git-object capture only applies to a Git worktree; an ordinary directory
+  // always stores its own content-addressed blobs.
+  const gitObjectFormat = source.state.type === 'git' ? options.gitObjectFormat : undefined
   const gitCapture = gitObjectFormat === undefined
     ? undefined
     : {
@@ -135,8 +137,8 @@ export async function captureStableTree(options: {
     })
     const second = await captureTree(options)
     if (first.treeHash === second.treeHash
-      && sameRepositoryFence(first.source.state, second.source.state)
-      && arraysEqual(first.source.state.stagedPaths, second.source.state.stagedPaths)
+      && sameWorkspaceFence(first.source.state, second.source.state)
+      && sameStagedPaths(first.source, second.source)
       && arraysEqual(first.source.paths, second.source.paths)) {
       return second
     }
@@ -144,6 +146,12 @@ export async function captureStableTree(options: {
   throw new ChangeLedgerError('WORKSPACE_CHANGED_DURING_CAPTURE', 'workspace did not remain stable across repeated full-tree captures')
 }
 
+/** Whether two captures observed the same index state; ordinary directories have none. */
+function sameStagedPaths(left: WorkspaceSnapshotSource, right: WorkspaceSnapshotSource): boolean {
+  if (left.state.type !== 'git' || right.state.type !== 'git') return true
+  return arraysEqual(left.state.stagedPaths, right.state.stagedPaths)
+}
+
 /** Compute stable path-level differences between two captured trees. */
 export function diffTrees(
   before: Readonly<Record<string, SnapshotEntry>>,

package/src/types.ts

@@ -34,7 +34,8 @@ export interface SymlinkSnapshotEntry {
 export type SnapshotEntry = FileSnapshotEntry | SymlinkSnapshotEntry
 
 /** Git facts that fence a restore point to the repository state it observed. */
-export interface RepositoryState {
+export interface GitWorkspaceState {
+  readonly type: 'git'
   readonly root: string
   readonly commonDir: string
   readonly head?: string
@@ -43,6 +44,18 @@ export interface RepositoryState {
   readonly stagedPaths: readonly string[]
 }
 
+/** Identity of an ordinary directory workspace captured without Git. */
+export interface DirectoryWorkspaceState {
+  readonly type: 'directory'
+  readonly root: string
+}
+
+/** Workspace facts that fence a restore point to the state it observed. */
+export type WorkspaceState = GitWorkspaceState | DirectoryWorkspaceState
+
+/** @deprecated Use `WorkspaceState`; the durable manifest field keeps its original name. */
+export type RepositoryState = WorkspaceState
+
 /** Why a restore point exists. */
 export type RestorePointKind = 'user' | 'rescue' | 'turn'
 
@@ -89,8 +102,10 @@ export interface GitCheckpointMetadata {
 }
 
 /** Automatic turn checkpoint whose content is stored in the repository object database. */
-export interface RestorePointManifestV2 extends Omit<RestorePointManifestV1, 'version' | 'treeHash'> {
+export interface RestorePointManifestV2 extends Omit<RestorePointManifestV1, 'version' | 'treeHash' | 'repository'> {
   readonly version: typeof GIT_CHECKPOINT_FORMAT_VERSION
+  /** Git-native checkpoints only exist for a Git worktree. */
+  readonly repository: GitWorkspaceState
   /** Deterministic sidecar identity; Git tree integrity is verified separately. */
   readonly treeHash: string
   readonly git: GitCheckpointMetadata
@@ -126,6 +141,7 @@ export interface RestorePointSummary {
   readonly id: RestorePointId
   readonly kind: RestorePointKind
   readonly workspace: string
+  readonly workspaceType: WorkspaceState['type']
   readonly sessionId?: string
   readonly label?: string
   readonly parentRestorePoint?: RestorePointId

package/src/validate.ts

@@ -102,7 +102,8 @@ export function parseManifest(value: unknown): RestorePointManifest {
   }
   if (version === LEDGER_FORMAT_VERSION) return { version, ...common }
   if (restorePointKind !== 'turn') corrupt('Git-native v2 restore points are automatic turn checkpoints')
-  return { version, ...common, git: parseGitCheckpoint(record.git, id) }
+  if (repository.type !== 'git') corrupt('Git-native v2 restore points must fence a Git workspace')
+  return { version, ...common, repository, git: parseGitCheckpoint(record.git, id) }
 }
 
 /** Parse an untrusted durable restore-operation journal. */
@@ -158,9 +159,27 @@ export function validateBlobHash(value: string): string {
   return value
 }
 
+/**
+ * Parse the durable workspace fence of one manifest.
+ *
+ * A missing `type` is the only legacy interpretation: manifests written before
+ * ordinary-directory support are always Git workspaces and are upgraded in
+ * memory. Directory fences must not carry Git-only fields.
+ * @param value - persisted `repository` field.
+ * @returns the validated workspace state.
+ */
 function parseRepository(value: unknown): RepositoryState {
   const record = objectRecord(value, 'repository state')
   const root = absoluteString(record, 'root')
+  if (record.type === 'directory') {
+    for (const key of ['commonDir', 'head', 'branch', 'operation', 'stagedPaths']) {
+      if (record[key] !== undefined) corrupt(`directory workspace state must not contain ${key}`)
+    }
+    return { type: 'directory', root }
+  }
+  if (record.type !== undefined && record.type !== 'git') {
+    corrupt('workspace state type must be "git" or "directory"')
+  }
   const commonDir = absoluteString(record, 'commonDir')
   const head = optionalHash(record, 'head')
   const branch = optionalString(record, 'branch')
@@ -169,6 +188,7 @@ function parseRepository(value: unknown): RepositoryState {
   if (!Array.isArray(stagedValue)) corrupt('repository stagedPaths must be an array')
   const stagedPaths = stagedValue.map((path) => validateRelativePath(requireString(path, 'staged path')))
   return {
+    type: 'git',
     root,
     commonDir,
     ...(head === undefined ? {} : { head }),

package/src/workspace.ts

@@ -0,0 +1,66 @@
+import { discoverDirectory, discoverDirectoryRoot, type DirectorySnapshotSource } from './directory.js'
+import {
+  discoverRepositoryOptional,
+  discoverRepositoryRootOptional,
+  sameRepositoryFence,
+  type RepositorySnapshotSource,
+} from './git.js'
+import type { ResolvedChangeLedgerConfig, WorkspaceState } from './types.js'
+
+/** Eligible snapshot source for either supported workspace mode. */
+export type WorkspaceSnapshotSource = RepositorySnapshotSource | DirectorySnapshotSource
+
+/**
+ * Discover the owning Git worktree, or treat `cwd` itself as an ordinary
+ * directory when it is not inside any repository.
+ * @param cwd - working directory the Session runs in.
+ * @param config - capture limits applied to ordinary-directory enumeration.
+ * @param signal - optional caller cancellation.
+ * @returns the snapshot source for the owning workspace.
+ */
+export async function discoverWorkspace(
+  cwd: string,
+  config: Pick<ResolvedChangeLedgerConfig, 'maxFiles' | 'maxFileBytes'>,
+  signal?: AbortSignal,
+): Promise<WorkspaceSnapshotSource> {
+  const repository = await discoverRepositoryOptional(cwd, signal)
+  return repository ?? discoverDirectory(cwd, config, signal)
+}
+
+/** Workspace mode and root resolved without inventorying any files. */
+export interface WorkspaceIdentity {
+  readonly type: WorkspaceState['type']
+  readonly root: string
+}
+
+/**
+ * Resolve the workspace mode and root without inventorying files, for callers
+ * that only need to address the workspace (locks, skip markers, storage purge).
+ * @param cwd - working directory the Session runs in.
+ * @param signal - optional caller cancellation.
+ * @returns the workspace mode and canonical root.
+ */
+export async function discoverWorkspaceIdentity(cwd: string, signal?: AbortSignal): Promise<WorkspaceIdentity> {
+  const root = await discoverRepositoryRootOptional(cwd, signal)
+  return root === undefined
+    ? { type: 'directory', root: await discoverDirectoryRoot(cwd) }
+    : { type: 'git', root }
+}
+
+/** Resolve the workspace root without inventorying its files. */
+export async function discoverWorkspaceRoot(cwd: string, signal?: AbortSignal): Promise<string> {
+  return (await discoverWorkspaceIdentity(cwd, signal)).root
+}
+
+/**
+ * Whether two fences still describe the same workspace.
+ *
+ * Git workspaces keep the full repository fence (HEAD, branch, operation);
+ * ordinary directories only own their canonical root, so a moved or recreated
+ * root is the only thing that can invalidate them.
+ */
+export function sameWorkspaceFence(left: WorkspaceState, right: WorkspaceState): boolean {
+  if (left.type !== right.type || left.root !== right.root) return false
+  if (left.type === 'directory' || right.type === 'directory') return true
+  return sameRepositoryFence(left, right)
+}