@documentation-robotics/cli 0.2.0 → 0.4.0

package/dist/core/staged-changeset-storage.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/core/staged-changeset-storage.ts"],
-  "sourcesContent": ["/**\n * StagedChangesetStorage - Handles YAML-based storage for staged changesets\n *\n * Manages the new storage structure:\n * documentation-robotics/changesets/{changeset-id}/\n * \u251C\u2500\u2500 metadata.yaml       # Name, description, dates, status, base snapshot\n * \u2514\u2500\u2500 changes.yaml        # Delta-only change records\n */\n\nimport { readFile, writeFile, readdir, rm } from \"fs/promises\";\nimport { fileExists, ensureDir } from \"../utils/file-io.js\";\nimport { FileLock } from \"../utils/file-lock.js\";\nimport path from \"path\";\nimport yaml from \"yaml\";\nimport ansis from \"ansis\";\nimport type { StagedChangesetData, StagedChange } from \"./changeset.js\";\nimport { Changeset } from \"./changeset.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\n\n/**\n * Storage manager for staged changesets using YAML format\n */\nexport class StagedChangesetStorage {\n  private changesetsDir: string;\n\n  constructor(rootPath: string) {\n    // Store changesets in documentation-robotics/changesets/ directory\n    this.changesetsDir = path.join(rootPath, \"documentation-robotics\", \"changesets\");\n  }\n\n  /**\n   * Create a new staged changeset directory structure\n   */\n  async create(\n    id: string,\n    name: string,\n    description: string | undefined,\n    baseSnapshot: string\n  ): Promise<Changeset> {\n    const now = new Date().toISOString();\n    const sanitizedId = this.sanitizeId(id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n\n    // Create directory structure\n    await ensureDir(changesetPath);\n\n    // Create metadata\n    const metadata: Omit<StagedChangesetData, \"changes\"> = {\n      id: sanitizedId,\n      name,\n      description,\n      created: now,\n      modified: now,\n      status: \"staged\",\n      baseSnapshot,\n      stats: {\n        additions: 0,\n        modifications: 0,\n        deletions: 0,\n      },\n    };\n\n    // Write metadata.yaml\n    await writeFile(path.join(changesetPath, \"metadata.yaml\"), yaml.stringify(metadata), \"utf-8\");\n\n    // Write empty changes.yaml\n    await writeFile(path.join(changesetPath, \"changes.yaml\"), yaml.stringify([]), \"utf-8\");\n\n    // Return constructed changeset object\n    return new Changeset({\n      id: sanitizedId,\n      name,\n      description,\n      created: now,\n      modified: now,\n      status: \"staged\",\n      baseSnapshot,\n      changes: [],\n      stats: metadata.stats,\n    });\n  }\n\n  /**\n   * Load a staged changeset from YAML files\n   */\n  async load(id: string): Promise<Changeset | null> {\n    const sanitizedId = this.sanitizeId(id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n    const metadataPath = path.join(changesetPath, \"metadata.yaml\");\n    const changesPath = path.join(changesetPath, \"changes.yaml\");\n\n    // Check if changeset directory exists\n    if (!(await fileExists(changesetPath))) {\n      return null; // Changeset doesn't exist - this is OK\n    }\n\n    // Changeset directory exists - files SHOULD be present\n    const metadataExists = await fileExists(metadataPath);\n    const changesExists = await fileExists(changesPath);\n\n    if (!metadataExists || !changesExists) {\n      // Changeset directory exists but required files are missing - this is corruption\n      throw new Error(\n        `Changeset '${id}' is corrupted (missing ${!metadataExists ? \"metadata.yaml\" : \"changes.yaml\"}). ` +\n          `Location: ${changesetPath}\\n` +\n          `This may indicate disk failure or incomplete write. Check disk health and restore from backup if available.`\n      );\n    }\n\n    try {\n      // Load metadata\n      const metadataContent = await readFile(metadataPath, \"utf-8\");\n      const metadata = yaml.parse(metadataContent);\n\n      // Load changes\n      const changesContent = await readFile(changesPath, \"utf-8\");\n      const changes = yaml.parse(changesContent) || [];\n\n      // Construct changeset object\n      const data: StagedChangesetData = {\n        id: metadata.id,\n        name: metadata.name,\n        description: metadata.description,\n        created: metadata.created,\n        modified: metadata.modified,\n        status: metadata.status,\n        baseSnapshot: metadata.baseSnapshot,\n        changes: changes as StagedChange[],\n        stats: metadata.stats || { additions: 0, modifications: 0, deletions: 0 },\n      };\n\n      return Changeset.fromJSON(data);\n    } catch (error) {\n      // YAML parsing or file read error - provide detailed guidance\n      throw new Error(\n        `Failed to load changeset '${id}': YAML parsing failed.\\n` +\n          `Error: ${getErrorMessage(error)}\\n` +\n          `Location: ${metadataPath}\\n` +\n          `This indicates file corruption. Try:\\n` +\n          `  1. Validate YAML syntax with: yamllint ${metadataPath}\\n` +\n          `  2. Restore from backup if available\\n` +\n          `  3. Manually edit to fix syntax errors`\n      );\n    }\n  }\n\n  /**\n   * Save a staged changeset to YAML files\n   */\n  async save(changeset: Changeset): Promise<void> {\n    if (!changeset.id) {\n      throw new Error(\"Changeset must have an id to be saved in YAML format\");\n    }\n\n    const sanitizedId = this.sanitizeId(changeset.id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n    await ensureDir(changesetPath);\n\n    // Prepare metadata (all fields except changes)\n    const metadata = {\n      id: changeset.id,\n      name: changeset.name,\n      description: changeset.description,\n      created: changeset.created,\n      modified: changeset.modified,\n      status: changeset.status,\n      baseSnapshot: changeset.baseSnapshot,\n      stats: changeset.stats || { additions: 0, modifications: 0, deletions: 0 },\n    };\n\n    // Write metadata.yaml\n    await writeFile(path.join(changesetPath, \"metadata.yaml\"), yaml.stringify(metadata), \"utf-8\");\n\n    // Write changes.yaml\n    await writeFile(\n      path.join(changesetPath, \"changes.yaml\"),\n      yaml.stringify(changeset.changes),\n      \"utf-8\"\n    );\n  }\n\n  /**\n   * List all staged changesets\n   */\n  async list(): Promise<Changeset[]> {\n    if (!(await fileExists(this.changesetsDir))) {\n      return [];\n    }\n\n    try {\n      const entries = await readdir(this.changesetsDir, { withFileTypes: true });\n      const changesets: Changeset[] = [];\n      let skippedCount = 0;\n\n      for (const entry of entries) {\n        if (entry.isDirectory()) {\n          try {\n            const changeset = await this.load(entry.name);\n            if (changeset) {\n              changesets.push(changeset);\n            } else {\n              // load() returned null - directory exists but no valid changeset\n              console.warn(\n                ansis.yellow(\n                  `\u26A0 Warning: Changeset directory '${entry.name}' exists but could not be loaded (may be corrupted)`\n                )\n              );\n              skippedCount++;\n            }\n          } catch (loadError) {\n            // load() threw an error - this is a corrupted changeset\n            console.warn(\n              ansis.yellow(\n                `\u26A0 Warning: Failed to load changeset '${entry.name}': ${loadError instanceof Error ? loadError.message : String(loadError)}`\n              )\n            );\n            skippedCount++;\n          }\n        }\n      }\n\n      // Show summary if any were skipped\n      if (skippedCount > 0) {\n        console.warn(\n          ansis.yellow(`\\n\u26A0 ${skippedCount} changeset(s) could not be loaded and were skipped.`) +\n            ansis.dim(`\\nRun 'dr changeset validate' to check for corruption and repair options.`)\n        );\n      }\n\n      return changesets;\n    } catch (error) {\n      throw new Error(\n        `Failed to list changesets: ${getErrorMessage(error)}`\n      );\n    }\n  }\n\n  /**\n   * Delete a staged changeset\n   */\n  async delete(id: string): Promise<void> {\n    const sanitizedId = this.sanitizeId(id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n\n    if (!(await fileExists(changesetPath))) {\n      // List available changesets to help user\n      const available = await this.list();\n      const availableIds = available.map((cs) => cs.id).join(\", \");\n\n      throw new Error(\n        `Changeset '${id}' not found.\\n` +\n          `Available changesets: ${availableIds || \"(none)\"}\\n` +\n          `Run 'dr changeset list' to see all changesets.`\n      );\n    }\n\n    try {\n      await rm(changesetPath, { recursive: true, force: true });\n    } catch (error) {\n      throw new Error(\n        `Failed to delete changeset '${id}': ${getErrorMessage(error)}`\n      );\n    }\n  }\n\n  /**\n   * Add or update a change in the changeset's changes.yaml\n   *\n   * Uses file locking to prevent concurrent modification race conditions\n   * Assigns sequence number atomically inside the lock to prevent duplicates\n   *\n   * @returns The assigned sequence number for the change\n   * @throws {Error} If lock acquisition, changeset load, save, or lock release fails\n   */\n  async addChange(id: string, change: Omit<StagedChange, \"sequenceNumber\">): Promise<number> {\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n\n    try {\n      return await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n\n        // Assign sequence number atomically inside the lock\n        // This prevents race conditions when multiple concurrent operations\n        // try to add changes at the same time\n        const sequenceNumber = changeset.changes.length;\n        const stagedChange: StagedChange = {\n          ...change,\n          sequenceNumber,\n        };\n\n        changeset.changes.push(stagedChange);\n        changeset.updateModified();\n\n        await this.save(changeset);\n\n        return sequenceNumber;\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n\n      // Detect lock-specific errors\n      if (errorMessage.includes(\"lock\") || errorMessage.includes(\"timeout\")) {\n        const lockFilePath = path.join(changesetPath, \".lock\");\n\n        throw new Error(\n          `Failed to add change to changeset '${id}': Lock acquisition failed.\\n` +\n            `Error: ${errorMessage}\\n\\n` +\n            `This usually means another dr process is modifying this changeset.\\n` +\n            `If no other processes are running, a stale lock file may exist.\\n\\n` +\n            `To resolve:\\n` +\n            `  1. Wait for other operations to complete\\n` +\n            `  2. Check for running dr processes: ps aux | grep dr\\n` +\n            `  3. If no processes found, remove stale lock: rm \"${lockFilePath}\"\\n` +\n            `  4. Retry the operation`\n        );\n      }\n\n      // Generic error with context\n      throw new Error(\n        `Failed to add change to changeset '${id}': ${errorMessage}\\n` +\n          `Changeset path: ${changesetPath}`\n      );\n    }\n  }\n\n  /**\n   * Remove a change by element ID\n   *\n   * Uses file locking to prevent concurrent modification race conditions\n   *\n   * @throws {Error} If lock acquisition, changeset load, save, or lock release fails\n   */\n  async removeChange(id: string, elementId: string): Promise<void> {\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n\n    try {\n      await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n\n        // Filter out changes for this element\n        const filtered = changeset.changes.filter((c) => c.elementId !== elementId);\n\n        // Reconstruct changes with updated sequence numbers\n        changeset.changes = filtered.map((c, idx) => ({\n          ...c,\n          sequenceNumber: idx,\n        }));\n\n        changeset.updateModified();\n\n        await this.save(changeset);\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n\n      // Detect lock-specific errors\n      if (errorMessage.includes(\"lock\") || errorMessage.includes(\"timeout\")) {\n        const lockFilePath = path.join(changesetPath, \".lock\");\n\n        throw new Error(\n          `Failed to remove change from changeset '${id}': Lock acquisition failed.\\n` +\n            `Error: ${errorMessage}\\n\\n` +\n            `This usually means another dr process is modifying this changeset.\\n` +\n            `If no other processes are running, a stale lock file may exist.\\n\\n` +\n            `To resolve:\\n` +\n            `  1. Wait for other operations to complete\\n` +\n            `  2. Check for running dr processes: ps aux | grep dr\\n` +\n            `  3. If no processes found, remove stale lock: rm \"${lockFilePath}\"\\n` +\n            `  4. Retry the operation`\n        );\n      }\n\n      // Generic error with context\n      throw new Error(\n        `Failed to remove change from changeset '${id}': ${errorMessage}\\n` +\n          `Changeset path: ${changesetPath}`\n      );\n    }\n  }\n\n  /**\n   * Update an existing change in-place within the changeset's changes.yaml\n   *\n   * Atomically replaces the change for the given elementId under a single file lock,\n   * preventing data loss if the process is interrupted between a remove and add.\n   * The original sequence number is preserved so commit-ordering is unaffected.\n   *\n   * @throws {Error} If changeset not found, elementId not found in changes, or I/O error\n   */\n  async updateChange(\n    id: string,\n    elementId: string,\n    updated: Omit<StagedChange, \"sequenceNumber\">\n  ): Promise<void> {\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n\n    try {\n      await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n\n        const index = changeset.changes.findIndex((c) => c.elementId === elementId);\n        if (index === -1) {\n          throw new Error(`No change for element '${elementId}' in changeset '${id}'`);\n        }\n\n        // Spread existing entry first so runtime fields like sequenceNumber and timestamp\n        // are preserved. Then apply the updated fields. Since `updated` is\n        // Omit<StagedChange, \"sequenceNumber\">, it will not overwrite sequenceNumber.\n        const existing = changeset.changes[index] as any;\n        changeset.changes[index] = {\n          ...existing,\n          ...updated,\n          sequenceNumber: existing.sequenceNumber ?? index,\n        } as any;\n\n        changeset.updateModified();\n        await this.save(changeset);\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n      throw new Error(\n        `Failed to update change in changeset '${id}': ${errorMessage}\\n` +\n          `Changeset path: ${changesetPath}`\n      );\n    }\n  }\n\n  /**\n   * Get the storage path for a changeset\n   */\n  getChangesetPath(id: string): string {\n    const sanitizedId = this.sanitizeId(id);\n    return path.join(this.changesetsDir, sanitizedId);\n  }\n\n  /**\n   * Get the root changesets directory\n   */\n  getChangesetsDir(): string {\n    return this.changesetsDir;\n  }\n\n  /**\n   * Sanitize changeset ID for safe use in file paths\n   * Prevents path traversal by removing special characters and path separators\n   */\n  private sanitizeId(id: string): string {\n    const sanitized = id\n      .replace(/\\.\\./g, \"\") // Remove .. (parent directory)\n      .replace(/^\\/+/, \"\") // Remove leading slashes\n      .replace(/^[A-Z]:\\\\/g, \"\") // Remove Windows drive letters\n      .toLowerCase()\n      .replace(/\\s+/g, \"-\") // Replace spaces with hyphens\n      .replace(/[^a-z0-9-]/g, \"\"); // Keep only alphanumeric and hyphens\n\n    if (!sanitized) {\n      throw new Error(\n        `Invalid changeset ID '${id}': results in empty string after sanitization. ` +\n          `ID must contain at least one alphanumeric character.`\n      );\n    }\n\n    return sanitized;\n  }\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * StagedChangesetStorage - Handles YAML-based storage for staged changesets\n *\n * Manages the new storage structure:\n * documentation-robotics/changesets/{changeset-id}/\n * \u251C\u2500\u2500 metadata.yaml       # Name, description, dates, status, base snapshot\n * \u2514\u2500\u2500 changes.yaml        # Delta-only change records\n */\n\nimport { readFile, writeFile, readdir, rm } from \"fs/promises\";\nimport { fileExists, ensureDir } from \"../utils/file-io.js\";\nimport { FileLock } from \"../utils/file-lock.js\";\nimport path from \"path\";\nimport yaml from \"yaml\";\nimport ansis from \"ansis\";\nimport type { StagedChangesetData, StagedChange, UnstagedChange } from \"./changeset.js\";\nimport { Changeset, compactChange, nextSequenceNumber, sequenceOf, withSequenceNumbers } from \"./changeset.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\n\n/**\n * How many unstaged changes a changeset keeps as tombstones. Older ones are dropped (and\n * `unstagedPrunedThrough` records how far), so a delta reaching back past them says it is\n * approximate.\n */\nexport const MAX_UNSTAGED_TOMBSTONES = 200;\n\n/**\n * Reads the tombstone list from metadata.yaml, keeping the well-formed entries. Malformed entries\n * are reported, not silently dropped: the changeset still loads, and its changes are untouched.\n */\nfunction readTombstones(value: unknown, id: string): UnstagedChange[] | undefined {\n  if (value === undefined || value === null) return undefined;\n  if (!Array.isArray(value)) {\n    console.warn(ansis.yellow(`\u26A0 Changeset '${id}': 'unstaged' in metadata.yaml is not a list; ignoring it`));\n    return undefined;\n  }\n  const valid = value.filter(\n    (t): t is UnstagedChange =>\n      !!t &&\n      typeof t === \"object\" &&\n      typeof t.sequence === \"number\" &&\n      typeof t.removedAt === \"number\" &&\n      !!t.change &&\n      typeof t.change === \"object\" &&\n      typeof t.change.type === \"string\" &&\n      typeof t.change.elementId === \"string\"\n  );\n  if (valid.length < value.length) {\n    console.warn(\n      ansis.yellow(\n        `\u26A0 Changeset '${id}': ignoring ${value.length - valid.length} malformed 'unstaged' entr(ies) in metadata.yaml`\n      )\n    );\n  }\n  return valid;\n}\n\n/** Appends tombstones, keeping the newest MAX_UNSTAGED_TOMBSTONES and recording how far it trimmed. */\nfunction addTombstones(changeset: Changeset, tombstones: UnstagedChange[]): void {\n  changeset.unstaged = [...changeset.unstaged, ...tombstones];\n  if (changeset.unstaged.length > MAX_UNSTAGED_TOMBSTONES) {\n    const dropped = changeset.unstaged.slice(0, changeset.unstaged.length - MAX_UNSTAGED_TOMBSTONES);\n    changeset.unstaged = changeset.unstaged.slice(-MAX_UNSTAGED_TOMBSTONES);\n    changeset.unstagedPrunedThrough = Math.max(changeset.unstagedPrunedThrough ?? -1, ...dropped.map((t) => t.removedAt));\n  }\n}\n\n/**\n * Storage manager for staged changesets using YAML format\n */\nexport class StagedChangesetStorage {\n  private changesetsDir: string;\n\n  constructor(rootPath: string) {\n    // Store changesets in documentation-robotics/changesets/ directory\n    this.changesetsDir = path.join(rootPath, \"documentation-robotics\", \"changesets\");\n  }\n\n  /**\n   * Create a new staged changeset directory structure\n   */\n  async create(\n    id: string,\n    name: string,\n    description: string | undefined,\n    baseSnapshot: string\n  ): Promise<Changeset> {\n    const now = new Date().toISOString();\n    const sanitizedId = this.sanitizeId(id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n\n    // Create directory structure\n    await ensureDir(changesetPath);\n\n    // Create metadata\n    const metadata: Omit<StagedChangesetData, \"changes\"> = {\n      id: sanitizedId,\n      name,\n      description,\n      created: now,\n      modified: now,\n      status: \"staged\",\n      baseSnapshot,\n      stats: {\n        additions: 0,\n        modifications: 0,\n        deletions: 0,\n      },\n    };\n\n    // Write metadata.yaml\n    await writeFile(path.join(changesetPath, \"metadata.yaml\"), yaml.stringify(metadata), \"utf-8\");\n\n    // Write empty changes.yaml\n    await writeFile(path.join(changesetPath, \"changes.yaml\"), yaml.stringify([]), \"utf-8\");\n\n    // Return constructed changeset object\n    return new Changeset({\n      id: sanitizedId,\n      name,\n      description,\n      created: now,\n      modified: now,\n      status: \"staged\",\n      baseSnapshot,\n      changes: [],\n      stats: metadata.stats,\n    });\n  }\n\n  /**\n   * Load a staged changeset from YAML files\n   */\n  async load(id: string): Promise<Changeset | null> {\n    const sanitizedId = this.sanitizeId(id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n    const metadataPath = path.join(changesetPath, \"metadata.yaml\");\n    const changesPath = path.join(changesetPath, \"changes.yaml\");\n\n    // Check if changeset directory exists\n    if (!(await fileExists(changesetPath))) {\n      return null; // Changeset doesn't exist - this is OK\n    }\n\n    // Changeset directory exists - files SHOULD be present\n    const metadataExists = await fileExists(metadataPath);\n    const changesExists = await fileExists(changesPath);\n\n    if (!metadataExists || !changesExists) {\n      // Changeset directory exists but required files are missing - this is corruption\n      throw new Error(\n        `Changeset '${id}' is corrupted (missing ${!metadataExists ? \"metadata.yaml\" : \"changes.yaml\"}). ` +\n          `Location: ${changesetPath}\\n` +\n          `This may indicate disk failure or incomplete write. Check disk health and restore from backup if available.`\n      );\n    }\n\n    try {\n      // Load metadata\n      const metadataContent = await readFile(metadataPath, \"utf-8\");\n      const metadata = yaml.parse(metadataContent);\n\n      // Load changes\n      const changesContent = await readFile(changesPath, \"utf-8\");\n      const changes = yaml.parse(changesContent) || [];\n\n      // Construct changeset object\n      const data: StagedChangesetData = {\n        id: metadata.id,\n        name: metadata.name,\n        description: metadata.description,\n        created: metadata.created,\n        modified: metadata.modified,\n        status: metadata.status,\n        baseSnapshot: metadata.baseSnapshot,\n        changes: changes as StagedChange[],\n        stats: metadata.stats || { additions: 0, modifications: 0, deletions: 0 },\n        ...(typeof metadata.lastSequence === \"number\" ? { lastSequence: metadata.lastSequence } : {}),\n        ...(typeof metadata.unstagedPrunedThrough === \"number\"\n          ? { unstagedPrunedThrough: metadata.unstagedPrunedThrough }\n          : {}),\n      };\n      const unstaged = readTombstones(metadata.unstaged, id);\n      if (unstaged) data.unstaged = unstaged;\n\n      return Changeset.fromJSON(data);\n    } catch (error) {\n      // YAML parsing or file read error - provide detailed guidance\n      throw new Error(\n        `Failed to load changeset '${id}': YAML parsing failed.\\n` +\n          `Error: ${getErrorMessage(error)}\\n` +\n          `Location: ${metadataPath}\\n` +\n          `This indicates file corruption. Try:\\n` +\n          `  1. Validate YAML syntax with: yamllint ${metadataPath}\\n` +\n          `  2. Restore from backup if available\\n` +\n          `  3. Manually edit to fix syntax errors`\n      );\n    }\n  }\n\n  /**\n   * Save a staged changeset to YAML files\n   */\n  async save(changeset: Changeset): Promise<void> {\n    if (!changeset.id) {\n      throw new Error(\"Changeset must have an id to be saved in YAML format\");\n    }\n\n    const sanitizedId = this.sanitizeId(changeset.id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n    await ensureDir(changesetPath);\n\n    // A change staged in memory without a number gets the next unused one (never one an unstaged\n    // change or unstage event took); lastSequence then covers it.\n    const numbered = withSequenceNumbers(changeset.changes, nextSequenceNumber(changeset));\n    const lastSequence =\n      changeset.lastSequence !== undefined\n        ? Math.max(changeset.lastSequence, ...numbered.map((c) => c.sequenceNumber))\n        : undefined;\n\n    // Prepare metadata (all fields except changes)\n    const metadata = {\n      id: changeset.id,\n      name: changeset.name,\n      description: changeset.description,\n      created: changeset.created,\n      modified: changeset.modified,\n      status: changeset.status,\n      baseSnapshot: changeset.baseSnapshot,\n      stats: changeset.stats || { additions: 0, modifications: 0, deletions: 0 },\n      // Sequence bookkeeping (see nextSequenceNumber); absent on changesets never unstaged from.\n      ...(lastSequence !== undefined ? { lastSequence } : {}),\n      ...(changeset.unstagedPrunedThrough !== undefined\n        ? { unstagedPrunedThrough: changeset.unstagedPrunedThrough }\n        : {}),\n      ...(changeset.unstaged.length > 0 ? { unstaged: changeset.unstaged } : {}),\n    };\n\n    // Write metadata.yaml\n    await writeFile(path.join(changesetPath, \"metadata.yaml\"), yaml.stringify(metadata), \"utf-8\");\n\n    // Write changes.yaml\n    await writeFile(\n      path.join(changesetPath, \"changes.yaml\"),\n      yaml.stringify(numbered),\n      \"utf-8\"\n    );\n  }\n\n  /**\n   * List all staged changesets\n   */\n  async list(): Promise<Changeset[]> {\n    if (!(await fileExists(this.changesetsDir))) {\n      return [];\n    }\n\n    try {\n      const entries = await readdir(this.changesetsDir, { withFileTypes: true });\n      const changesets: Changeset[] = [];\n      let skippedCount = 0;\n\n      for (const entry of entries) {\n        if (entry.isDirectory()) {\n          try {\n            const changeset = await this.load(entry.name);\n            if (changeset) {\n              changesets.push(changeset);\n            } else {\n              // load() returned null - directory exists but no valid changeset\n              console.warn(\n                ansis.yellow(\n                  `\u26A0 Warning: Changeset directory '${entry.name}' exists but could not be loaded (may be corrupted)`\n                )\n              );\n              skippedCount++;\n            }\n          } catch (loadError) {\n            // load() threw an error - this is a corrupted changeset\n            console.warn(\n              ansis.yellow(\n                `\u26A0 Warning: Failed to load changeset '${entry.name}': ${loadError instanceof Error ? loadError.message : String(loadError)}`\n              )\n            );\n            skippedCount++;\n          }\n        }\n      }\n\n      // Show summary if any were skipped\n      if (skippedCount > 0) {\n        console.warn(\n          ansis.yellow(`\\n\u26A0 ${skippedCount} changeset(s) could not be loaded and were skipped.`) +\n            ansis.dim(`\\nRun 'dr changeset validate' to check for corruption and repair options.`)\n        );\n      }\n\n      return changesets;\n    } catch (error) {\n      throw new Error(\n        `Failed to list changesets: ${getErrorMessage(error)}`\n      );\n    }\n  }\n\n  /**\n   * Delete a staged changeset\n   */\n  async delete(id: string): Promise<void> {\n    const sanitizedId = this.sanitizeId(id);\n    const changesetPath = path.join(this.changesetsDir, sanitizedId);\n\n    if (!(await fileExists(changesetPath))) {\n      // List available changesets to help user\n      const available = await this.list();\n      const availableIds = available.map((cs) => cs.id).join(\", \");\n\n      throw new Error(\n        `Changeset '${id}' not found.\\n` +\n          `Available changesets: ${availableIds || \"(none)\"}\\n` +\n          `Run 'dr changeset list' to see all changesets.`\n      );\n    }\n\n    try {\n      await rm(changesetPath, { recursive: true, force: true });\n    } catch (error) {\n      throw new Error(\n        `Failed to delete changeset '${id}': ${getErrorMessage(error)}`\n      );\n    }\n  }\n\n  /**\n   * Add or update a change in the changeset's changes.yaml\n   *\n   * Uses file locking to prevent concurrent modification race conditions\n   * Assigns sequence number atomically inside the lock to prevent duplicates\n   *\n   * @returns The assigned sequence number for the change\n   * @throws {Error} If lock acquisition, changeset load, save, or lock release fails\n   */\n  async addChange(id: string, change: Omit<StagedChange, \"sequenceNumber\">): Promise<number> {\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n\n    try {\n      return await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n\n        // Assign sequence number atomically inside the lock\n        // This prevents race conditions when multiple concurrent operations\n        // try to add changes at the same time. One past every number used so far (unstaged\n        // changes and unstage events included), so a number is never reused and a revision\n        // always names the same prefix of the plan.\n        const sequenceNumber = nextSequenceNumber(changeset);\n        const stagedChange: StagedChange = {\n          ...change,\n          sequenceNumber,\n        };\n\n        changeset.changes = withSequenceNumbers(changeset.changes);\n        changeset.changes.push(stagedChange);\n        changeset.lastSequence = sequenceNumber;\n        changeset.updateModified();\n\n        await this.save(changeset);\n\n        return sequenceNumber;\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n\n      // Detect lock-specific errors\n      if (errorMessage.includes(\"lock\") || errorMessage.includes(\"timeout\")) {\n        const lockFilePath = path.join(changesetPath, \".lock\");\n\n        throw new Error(\n          `Failed to add change to changeset '${id}': Lock acquisition failed.\\n` +\n            `Error: ${errorMessage}\\n\\n` +\n            `This usually means another dr process is modifying this changeset.\\n` +\n            `If no other processes are running, a stale lock file may exist.\\n\\n` +\n            `To resolve:\\n` +\n            `  1. Wait for other operations to complete\\n` +\n            `  2. Check for running dr processes: ps aux | grep dr\\n` +\n            `  3. If no processes found, remove stale lock: rm \"${lockFilePath}\"\\n` +\n            `  4. Retry the operation`\n        );\n      }\n\n      // Generic error with context\n      throw new Error(\n        `Failed to add change to changeset '${id}': ${errorMessage}\\n` +\n          `Changeset path: ${changesetPath}`\n      );\n    }\n  }\n\n  /**\n   * Add several changes, and rewrite some staged ones in place, in one write: one load and one save\n   * instead of one per change. Additions take the next sequence numbers in order; a rewrite keeps\n   * its change's number and leaves a tombstone, as {@link updateChange} does.\n   *\n   * @returns The sequence numbers assigned to the additions, in order\n   */\n  async addChanges(\n    id: string,\n    changes: Array<Omit<StagedChange, \"sequenceNumber\">>,\n    rewrites: Array<{ elementId: string; change: Omit<StagedChange, \"sequenceNumber\"> }> = []\n  ): Promise<number[]> {\n    if (changes.length === 0 && rewrites.length === 0) return [];\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n    try {\n      return await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n        changeset.changes = withSequenceNumbers(changeset.changes, nextSequenceNumber(changeset));\n        for (const { elementId, change } of rewrites) {\n          const index = changeset.changes.findIndex((c) => c.elementId === elementId);\n          if (index === -1) {\n            throw new Error(`No change for element '${elementId}' in changeset '${id}'`);\n          }\n          const existing = changeset.changes[index] as StagedChange;\n          const rewrittenAt = nextSequenceNumber(changeset);\n          changeset.lastSequence = rewrittenAt;\n          addTombstones(changeset, [\n            { sequence: existing.sequenceNumber, removedAt: rewrittenAt, change: compactChange(existing), rewritten: true },\n          ]);\n          changeset.changes[index] = { ...existing, ...change, sequenceNumber: existing.sequenceNumber } as StagedChange;\n        }\n        const numbers: number[] = [];\n        for (const change of changes) {\n          const sequenceNumber = nextSequenceNumber(changeset);\n          const staged: StagedChange = { ...change, sequenceNumber };\n          changeset.changes.push(staged);\n          changeset.lastSequence = sequenceNumber;\n          numbers.push(sequenceNumber);\n        }\n        changeset.updateModified();\n        await this.save(changeset);\n        return numbers;\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n      if (errorMessage.includes(\"lock\") || errorMessage.includes(\"timeout\")) {\n        const lockFilePath = path.join(changesetPath, \".lock\");\n        throw new Error(\n          `Failed to add changes to changeset '${id}': Lock acquisition failed.\\n` +\n            `Error: ${errorMessage}\\n\\n` +\n            `This usually means another dr process is modifying this changeset.\\n` +\n            `If no other processes are running, a stale lock file may exist.\\n\\n` +\n            `To resolve:\\n` +\n            `  1. Wait for other operations to complete\\n` +\n            `  2. Check for running dr processes: ps aux | grep dr\\n` +\n            `  3. If no processes found, remove stale lock: rm \"${lockFilePath}\"\\n` +\n            `  4. Retry the operation`\n        );\n      }\n      throw new Error(`Failed to add changes to changeset '${id}': ${errorMessage}\\n` + `Changeset path: ${changesetPath}`);\n    }\n  }\n\n  /**\n   * Remove a change by element ID\n   *\n   * Uses file locking to prevent concurrent modification race conditions\n   *\n   * @throws {Error} If lock acquisition, changeset load, save, or lock release fails\n   */\n  async removeChange(id: string, elementId: string): Promise<void> {\n    await this.removeChanges(id, [elementId]);\n  }\n\n  /**\n   * Remove every change to any of `elementIds` in one write. The removal is one revision: it takes\n   * one sequence number, and each removed change is kept as a tombstone.\n   *\n   * Uses file locking to prevent concurrent modification race conditions\n   *\n   * @throws {Error} If lock acquisition, changeset load, save, or lock release fails\n   */\n  async removeChanges(id: string, elementIds: string[]): Promise<void> {\n    const keys = new Set(elementIds);\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n\n    try {\n      await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n\n        // Number any change that carries none by its position first, so the ones that stay keep\n        // the numbers they had. Remaining changes are not renumbered.\n        const numbered = withSequenceNumbers(changeset.changes);\n        const removed = numbered.filter((c) => keys.has(c.elementId));\n        changeset.changes = numbered.filter((c) => !keys.has(c.elementId));\n\n        if (removed.length > 0) {\n          // The unstage is a revision of its own: it takes the next sequence number, and each\n          // removed change is kept as a tombstone so the plan before it can be rebuilt.\n          const removedAt = nextSequenceNumber({ ...changeset, changes: numbered });\n          changeset.lastSequence = removedAt;\n          addTombstones(\n            changeset,\n            removed.map((c, index) => ({\n              sequence: sequenceOf(c, index),\n              removedAt,\n              change: compactChange(c),\n            }))\n          );\n        }\n\n        changeset.updateModified();\n\n        await this.save(changeset);\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n\n      // Detect lock-specific errors\n      if (errorMessage.includes(\"lock\") || errorMessage.includes(\"timeout\")) {\n        const lockFilePath = path.join(changesetPath, \".lock\");\n\n        throw new Error(\n          `Failed to remove change from changeset '${id}': Lock acquisition failed.\\n` +\n            `Error: ${errorMessage}\\n\\n` +\n            `This usually means another dr process is modifying this changeset.\\n` +\n            `If no other processes are running, a stale lock file may exist.\\n\\n` +\n            `To resolve:\\n` +\n            `  1. Wait for other operations to complete\\n` +\n            `  2. Check for running dr processes: ps aux | grep dr\\n` +\n            `  3. If no processes found, remove stale lock: rm \"${lockFilePath}\"\\n` +\n            `  4. Retry the operation`\n        );\n      }\n\n      // Generic error with context\n      throw new Error(\n        `Failed to remove change from changeset '${id}': ${errorMessage}\\n` +\n          `Changeset path: ${changesetPath}`\n      );\n    }\n  }\n\n  /**\n   * Update an existing change in-place within the changeset's changes.yaml\n   *\n   * Atomically replaces the change for the given elementId under a single file lock,\n   * preventing data loss if the process is interrupted between a remove and add.\n   * The original sequence number is preserved so commit-ordering is unaffected.\n   *\n   * @throws {Error} If changeset not found, elementId not found in changes, or I/O error\n   */\n  async updateChange(\n    id: string,\n    elementId: string,\n    updated: Omit<StagedChange, \"sequenceNumber\">\n  ): Promise<void> {\n    const changesetPath = this.getChangesetPath(id);\n    const lock = new FileLock(changesetPath);\n\n    try {\n      await lock.withLock(async () => {\n        const changeset = await this.load(id);\n        if (!changeset) {\n          throw new Error(`Changeset '${id}' not found`);\n        }\n\n        const index = changeset.changes.findIndex((c) => c.elementId === elementId);\n        if (index === -1) {\n          throw new Error(`No change for element '${elementId}' in changeset '${id}'`);\n        }\n\n        // Number every change first (an older changes.yaml may carry none), so the list is never\n        // left half numbered. Spread the existing entry so runtime fields like sequenceNumber and\n        // timestamp are preserved; `updated` omits sequenceNumber and cannot overwrite it.\n        changeset.changes = withSequenceNumbers(changeset.changes, nextSequenceNumber(changeset));\n        const existing = changeset.changes[index] as StagedChange;\n        // The rewrite is a revision of its own, like an unstage: it takes the next sequence number,\n        // and the version the change had is kept as a tombstone so the plan before it can be rebuilt.\n        const rewrittenAt = nextSequenceNumber(changeset);\n        changeset.lastSequence = rewrittenAt;\n        addTombstones(changeset, [\n          { sequence: existing.sequenceNumber, removedAt: rewrittenAt, change: compactChange(existing), rewritten: true },\n        ]);\n        changeset.changes[index] = {\n          ...existing,\n          ...updated,\n          sequenceNumber: existing.sequenceNumber,\n        } as StagedChange;\n\n        changeset.updateModified();\n        await this.save(changeset);\n      });\n    } catch (error) {\n      const errorMessage = getErrorMessage(error);\n      throw new Error(\n        `Failed to update change in changeset '${id}': ${errorMessage}\\n` +\n          `Changeset path: ${changesetPath}`\n      );\n    }\n  }\n\n  /**\n   * Change a changeset's name and/or description in place, under the changeset's file lock so a\n   * concurrent stage cannot be lost. Staged changes are untouched.\n   *\n   * @returns The updated changeset\n   * @throws {Error} If the changeset is not found, or on lock or I/O failure\n   */\n  async updateMetadata(\n    id: string,\n    patch: { name?: string; description?: string }\n  ): Promise<Changeset> {\n    const lock = new FileLock(this.getChangesetPath(id));\n    return lock.withLock(async () => {\n      const changeset = await this.load(id);\n      if (!changeset) {\n        throw new Error(`Changeset '${id}' not found`);\n      }\n      if (patch.name !== undefined) changeset.name = patch.name;\n      if (patch.description !== undefined) changeset.description = patch.description || undefined;\n      changeset.updateModified();\n      await this.save(changeset);\n      return changeset;\n    });\n  }\n\n  /**\n   * Get the storage path for a changeset\n   */\n  /**\n   * Remove every file in the changeset's directory except metadata.yaml and changes.yaml (and\n   * dotfiles such as a lock): e.g. the base index, once the changeset is discarded and nothing\n   * reads it again.\n   *\n   * @returns The names of the files removed\n   */\n  async removeSideFiles(id: string): Promise<string[]> {\n    const changesetPath = this.getChangesetPath(id);\n    if (!(await fileExists(changesetPath))) return [];\n    const keep = new Set([\"metadata.yaml\", \"changes.yaml\"]);\n    const removed: string[] = [];\n    for (const entry of await readdir(changesetPath, { withFileTypes: true })) {\n      if (keep.has(entry.name) || entry.name.startsWith(\".\") || !entry.isFile()) continue;\n      await rm(path.join(changesetPath, entry.name), { force: true });\n      removed.push(entry.name);\n    }\n    return removed;\n  }\n\n  getChangesetPath(id: string): string {\n    const sanitizedId = this.sanitizeId(id);\n    return path.join(this.changesetsDir, sanitizedId);\n  }\n\n  /**\n   * Get the root changesets directory\n   */\n  getChangesetsDir(): string {\n    return this.changesetsDir;\n  }\n\n  /**\n   * Sanitize changeset ID for safe use in file paths\n   * Prevents path traversal by removing special characters and path separators\n   */\n  private sanitizeId(id: string): string {\n    const sanitized = id\n      .replace(/\\.\\./g, \"\") // Remove .. (parent directory)\n      .replace(/^\\/+/, \"\") // Remove leading slashes\n      .replace(/^[A-Z]:\\\\/g, \"\") // Remove Windows drive letters\n      .toLowerCase()\n      .replace(/\\s+/g, \"-\") // Replace spaces with hyphens\n      .replace(/[^a-z0-9-]/g, \"\"); // Keep only alphanumeric and hyphens\n\n    if (!sanitized) {\n      throw new Error(\n        `Invalid changeset ID '${id}': results in empty string after sanitization. ` +\n          `ID must contain at least one alphanumeric character.`\n      );\n    }\n\n    return sanitized;\n  }\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/core/staged-source-reference.js

@@ -0,0 +1,28 @@
+const LEGACY_KEY = "sourceReference", KEY = "source_reference";
+function setStagedSourceReference(snapshot, ref) {
+  delete snapshot[LEGACY_KEY], snapshot[KEY] = ref ?? null;
+}
+function readStagedSourceReference(snapshot) {
+  if (!snapshot)
+    return { present: !1, value: void 0 };
+  for (const key of [LEGACY_KEY, KEY])
+    if (Object.prototype.hasOwnProperty.call(snapshot, key)) {
+      const raw = snapshot[key];
+      return { present: !0, value: raw && typeof raw == "object" ? raw : void 0 };
+    }
+  return { present: !1, value: void 0 };
+}
+function stagedSourceReference(snapshot) {
+  return readStagedSourceReference(snapshot).value;
+}
+function canonicalStagedSnapshot(snapshot) {
+  const sourceReference = readStagedSourceReference(snapshot), data = { ...snapshot };
+  return delete data[LEGACY_KEY], delete data[KEY], sourceReference.value && (data[KEY] = sourceReference.value), { data, sourceReference };
+}
+export {
+  canonicalStagedSnapshot,
+  readStagedSourceReference,
+  setStagedSourceReference,
+  stagedSourceReference
+};
+//# sourceMappingURL=staged-source-reference.js.map

package/dist/core/staged-source-reference.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/core/staged-source-reference.ts"],
+  "sourcesContent": ["/**\n * Source references inside staged element snapshots.\n *\n * A staged change's `before`/`after` is an element snapshot in the on-disk shape\n * (`Element.toJSON()`), so its source reference lives under the snake_case key\n * `source_reference`. A cleared reference is written as `source_reference: null`:\n * an update's `after` starts as a copy of `before`, so leaving the key out would\n * keep the old reference instead of clearing it.\n *\n * Earlier builds of `dr update` and the MCP `model_update` tool wrote the new\n * reference under a camelCase `sourceReference` key instead, next to the stale\n * snake_case copy. Those changes.yaml files exist, so readers go through\n * {@link readStagedSourceReference}, which honours the camelCase key when present.\n */\nimport type { SourceReference } from \"../types/source-reference.js\";\n\nconst LEGACY_KEY = \"sourceReference\";\nconst KEY = \"source_reference\";\n\n/**\n * Record a source-reference change on a staged element snapshot.\n * `undefined` clears the reference.\n */\nexport function setStagedSourceReference(\n  snapshot: Record<string, unknown>,\n  ref: SourceReference | undefined\n): void {\n  delete snapshot[LEGACY_KEY];\n  snapshot[KEY] = ref ?? null;\n}\n\n/**\n * Read a staged snapshot's source reference.\n *\n * `present` is false when the snapshot says nothing about the reference (neither\n * key is set), so a caller can keep whatever the element already has; when it is\n * true, `value` is the reference to use, `undefined` meaning cleared.\n */\nexport function readStagedSourceReference(\n  snapshot: Record<string, unknown> | undefined | null\n): { present: boolean; value: SourceReference | undefined } {\n  if (!snapshot) return { present: false, value: undefined };\n  // The legacy camelCase key carries the intended new value; its snake_case\n  // neighbour in such files is the stale copy of `before`.\n  for (const key of [LEGACY_KEY, KEY]) {\n    if (Object.prototype.hasOwnProperty.call(snapshot, key)) {\n      const raw = snapshot[key];\n      const value = raw && typeof raw === \"object\" ? (raw as SourceReference) : undefined;\n      return { present: true, value };\n    }\n  }\n  return { present: false, value: undefined };\n}\n\n/** The snapshot's source reference, or undefined when it has none or it is cleared. */\nexport function stagedSourceReference(\n  snapshot: Record<string, unknown> | undefined | null\n): SourceReference | undefined {\n  return readStagedSourceReference(snapshot).value;\n}\n\n/**\n * A copy of the snapshot in the canonical shape: the legacy camelCase key folded\n * into `source_reference`, and a cleared reference left out. Used where a\n * snapshot becomes an element (commit), so no stray keys reach the model.\n */\nexport function canonicalStagedSnapshot(snapshot: Record<string, unknown>): {\n  data: Record<string, unknown>;\n  sourceReference: { present: boolean; value: SourceReference | undefined };\n} {\n  const sourceReference = readStagedSourceReference(snapshot);\n  const data = { ...snapshot };\n  delete data[LEGACY_KEY];\n  delete data[KEY];\n  if (sourceReference.value) data[KEY] = sourceReference.value;\n  return { data, sourceReference };\n}\n"],
+  "mappings": "AAgBA,MAAM,aAAa,mBACb,MAAM;AAMN,SAAU,yBACd,UACA,KAAgC;AAEhC,SAAO,SAAS,UAAU,GAC1B,SAAS,GAAG,IAAI,OAAO;AACzB;AASM,SAAU,0BACd,UAAoD;AAEpD,MAAI,CAAC;AAAU,WAAO,EAAE,SAAS,IAAO,OAAO,OAAS;AAGxD,aAAW,OAAO,CAAC,YAAY,GAAG;AAChC,QAAI,OAAO,UAAU,eAAe,KAAK,UAAU,GAAG,GAAG;AACvD,YAAM,MAAM,SAAS,GAAG;AAExB,aAAO,EAAE,SAAS,IAAM,OADV,OAAO,OAAO,OAAQ,WAAY,MAA0B,OAC7C;IAC/B;AAEF,SAAO,EAAE,SAAS,IAAO,OAAO,OAAS;AAC3C;AAGM,SAAU,sBACd,UAAoD;AAEpD,SAAO,0BAA0B,QAAQ,EAAE;AAC7C;AAOM,SAAU,wBAAwB,UAAiC;AAIvE,QAAM,kBAAkB,0BAA0B,QAAQ,GACpD,OAAO,EAAE,GAAG,SAAQ;AAC1B,gBAAO,KAAK,UAAU,GACtB,OAAO,KAAK,GAAG,GACX,gBAAgB,UAAO,KAAK,GAAG,IAAI,gBAAgB,QAChD,EAAE,MAAM,gBAAe;AAChC;",
+  "names": []
+}

package/dist/core/staging-area.js

@@ -2,11 +2,14 @@ import path from "path";
 import ansis from "ansis";
 import { StagedChangesetStorage } from "./staged-changeset-storage.js";
 import { BaseSnapshotManager } from "./base-snapshot-manager.js";
+import { withSequenceNumbers } from "./changeset.js";
 import { ChangesetValidator } from "./changeset-validator.js";
 import { fileExists } from "../utils/file-io.js";
 import { createSha256Hash } from "../types/index.js";
 import { getErrorMessage } from "../utils/errors.js";
 import { Layer } from "./layer.js";
+import { canonicalStagedSnapshot } from "./staged-source-reference.js";
+import { elementIdentifiers, Relationships } from "./relationships.js";
 import { isValidLayerName } from "./layers.js";
 import { isTelemetryEnabled, startSpan, startActiveSpan, endSpan, emitLog, SeverityNumber } from "../telemetry/index.js";
 import { ModelReportOrchestrator } from "../reports/model-report-orchestrator.js";
@@ -49,7 +52,7 @@ class StagingAreaManager {
    * @returns VirtualProjectionEngine instance for computing merged model views
    */
   async getProjectionEngine() {
-    if (!this.projectionEngine) {
+    if (!this.projectionEngine && typeof this.model?.getVirtualProjectionEngine == "function" && (this.projectionEngine = this.model.getVirtualProjectionEngine()), !this.projectionEngine) {
       const { VirtualProjectionEngine } = await import("./virtual-projection.js");
       this.projectionEngine = new VirtualProjectionEngine(this.rootPath);
     }
@@ -62,7 +65,14 @@ class StagingAreaManager {
     if (!this.model)
       throw new Error("Model required for creating changesets");
     const id = this.generateChangesetId(), baseSnapshotId = await this.snapshotManager.captureSnapshot(this.model), changeset = await this.storage.create(id, name, description, baseSnapshotId);
-    return changeset.id = id, changeset.markStaged(), await this.storage.save(changeset), changeset;
+    changeset.id = id, changeset.markStaged(), await this.storage.save(changeset);
+    try {
+      const { captureBaseIndex, writeBaseIndex } = await import("./changeset-base-index.js");
+      await writeBaseIndex(this.rootPath, changeset.id, await captureBaseIndex(this.model));
+    } catch (error) {
+      console.warn(`Warning: could not record the base index for changeset '${name}': ${getErrorMessage(error)}. Verify and brief will fall back to what they can tell without it.`);
+    }
+    return changeset;
   }
   /**
    * Load a changeset by name or ID
@@ -91,6 +101,30 @@ class StagingAreaManager {
     const activeChangeset = await this.getActive();
     activeChangeset && activeChangeset.id === changeset.id && await this.clearActive(), await this.storage.delete(changeset.id);
   }
+  /**
+   * Rename a changeset and/or change its description (its stated intent). Staged changes,
+   * status and the active marker are untouched. Names stay unique: renaming to a name another
+   * changeset already has is refused.
+   *
+   * @param nameOrId - Changeset ID or current name
+   * @param patch - Fields to change; an empty description clears it
+   * @throws Error if the changeset is not found, or the new name is taken
+   */
+  async update(nameOrId, patch) {
+    const changeset = await this.load(nameOrId);
+    if (!changeset || !changeset.id)
+      throw new Error(`Changeset '${nameOrId}' not found`);
+    if (patch.name !== void 0) {
+      const name = patch.name.trim();
+      if (!name)
+        throw new Error("Changeset name cannot be empty");
+      const clash = (await this.storage.list()).find((cs) => cs.name === name && cs.id !== changeset.id);
+      if (clash)
+        throw new Error(`Another changeset (${clash.id}) is already named '${name}'`);
+      patch = { ...patch, name };
+    }
+    return this.storage.updateMetadata(changeset.id, patch);
+  }
   /**
    * Stage a change in the changeset.
    * Records the change in the staging area without applying to the base model.
@@ -111,7 +145,48 @@ class StagingAreaManager {
       ...change,
       timestamp: change.timestamp || (/* @__PURE__ */ new Date()).toISOString()
     };
-    await this.storage.addChange(changesetId, stagedChange), (await this.getProjectionEngine()).invalidateOnStage(changesetId, change.layerName);
+    await this.storage.addChange(changesetId, stagedChange), !change.type.startsWith("relationship-") && typeof this.model?.noteStagedLayer == "function" && this.model.noteStagedLayer(changesetId, change.layerName), (await this.getProjectionEngine()).invalidateOnStage(changesetId, change.layerName);
+  }
+  /**
+   * Stage several changes in one write, in order (see {@link stage}), and rewrite staged ones in
+   * place (see {@link restage}) in the same write. The changeset must be in 'staged' status.
+   */
+  async stageMany(changesetId, changes, rewrites = []) {
+    if (changes.length === 0 && rewrites.length === 0)
+      return;
+    this.validateChangesetId(changesetId);
+    const changeset = await this.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    if (changeset.status !== "staged")
+      throw new Error(`Cannot stage changes on changeset with status '${changeset.status}'. Changeset must have status 'staged' to accept new changes.`);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.storage.addChanges(changesetId, changes.map((change) => ({ ...change, timestamp: change.timestamp || now })), rewrites.map((r) => ({ elementId: r.elementId, change: { ...r.change, timestamp: r.change.timestamp || now } })));
+    const engine = await this.getProjectionEngine();
+    for (const layerName of new Set([...changes, ...rewrites.map((r) => r.change)].map((c) => c.layerName)))
+      engine.invalidateOnStage(changesetId, layerName);
+    if (typeof this.model?.noteStagedLayer == "function")
+      for (const change of changes)
+        change.type.startsWith("relationship-") || this.model.noteStagedLayer(changesetId, change.layerName);
+  }
+  /**
+   * Rewrite a staged change in place, keeping its sequence number: e.g. to fold an update of an
+   * element into the changeset's add of it. The changeset must be in 'staged' status.
+   *
+   * @param elementId - The key (`elementId`) of the change to rewrite
+   * @throws Error if the changeset is not found, not staged, or has no change with that key
+   */
+  async restage(changesetId, elementId, change) {
+    this.validateChangesetId(changesetId);
+    const changeset = await this.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    if (changeset.status !== "staged")
+      throw new Error(`Cannot change staged changes on changeset with status '${changeset.status}'. Changeset must have status 'staged'.`);
+    await this.storage.updateChange(changesetId, elementId, {
+      ...change,
+      timestamp: change.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    }), (await this.getProjectionEngine()).invalidateOnStage(changesetId, change.layerName);
   }
   /**
    * Unstage a specific element from the changeset.
@@ -131,6 +206,27 @@ class StagingAreaManager {
       throw new Error(`Cannot unstage changes on changeset with status '${changeset.status}'. Changeset must have status 'staged'.`);
     await this.storage.removeChange(changesetId, elementId), await (await this.getProjectionEngine()).invalidateOnUnstage(changesetId, elementId);
   }
+  /**
+   * Unstage several elements' changes in one write (one revision), e.g. a batch unstage.
+   * The changeset must be in 'staged' status.
+   *
+   * @param changesetId - ID of the changeset to unstage from
+   * @param elementIds - change keys (element IDs, or relationship change keys) to remove
+   * @throws Error if changeset ID is invalid, changeset not found, or not in 'staged' status
+   */
+  async unstageMany(changesetId, elementIds) {
+    if (elementIds.length === 0)
+      return;
+    if (elementIds.length === 1)
+      return this.unstage(changesetId, elementIds[0]);
+    this.validateChangesetId(changesetId);
+    const changeset = await this.load(changesetId);
+    if (!changeset)
+      throw new Error(`Changeset '${changesetId}' not found`);
+    if (changeset.status !== "staged")
+      throw new Error(`Cannot unstage changes on changeset with status '${changeset.status}'. Changeset must have status 'staged'.`);
+    await this.storage.removeChanges(changesetId, elementIds), await (await this.getProjectionEngine()).invalidateOnUnstage(changesetId);
+  }
   /**
    * Discard all changes in the changeset.
    * Clears all staged changes and marks the changeset as 'discarded'.
@@ -144,7 +240,7 @@ class StagingAreaManager {
     const changeset = await this.load(changesetId);
     if (!changeset)
       throw new Error(`Changeset '${changesetId}' not found`);
-    changeset.changes = [], changeset.status = "discarded", changeset.updateModified(), await this.storage.save(changeset), (await this.getProjectionEngine()).invalidateOnDiscard(changesetId);
+    changeset.changes = [], changeset.unstaged = [], changeset.status = "discarded", changeset.updateModified(), await this.storage.save(changeset), await this.storage.removeSideFiles(changesetId), (await this.getProjectionEngine()).invalidateOnDiscard(changesetId);
   }
   /**
    * Capture a base snapshot of the current model state for drift detection.
@@ -251,21 +347,32 @@ class StagingAreaManager {
         failed: 0,
         validation: {
           passed: !0,
-          errors: []
+          errors: [],
+          ran: shouldValidate
         }
       };
       if (shouldValidate && await startActiveSpan("staging.validate", async (validationSpan) => {
-        const validation = await this.validator.validateChangeset(model, changesetId);
-        if (validationSpan.setAttribute("validation.passed", validation.isValid()), validationSpan.setAttribute("validation.errorCount", validation.errors.length), validationSpan.setStatus({ code: 0 }), !validation.isValid())
-          throw result.validation.passed = !1, result.validation.errors = validation.errors.map((e) => e.message), emitLog(SeverityNumber.ERROR, "Validation failed", {
+        const report = await this.validator.validateChangesetReport(model, changesetId), validation = report.result;
+        if (result.validation.preExistingErrors = report.preExistingErrors.length, report.preExistingErrors.length > 0 && (result.validation.preExistingSample = report.preExistingErrors.slice(0, 10).map((e) => e.message), emitLog(SeverityNumber.WARN, "Pre-existing validation errors not counted against the changeset", {
+          "validation.preExistingErrorCount": report.preExistingErrors.length
+        })), report.baseValidationFailure && (result.validation.baseValidationFailure = report.baseValidationFailure, emitLog(SeverityNumber.WARN, "Base model could not be validated; every error counts", {
+          "validation.baseValidationFailure": report.baseValidationFailure
+        })), validationSpan.setAttribute("validation.passed", validation.isValid()), validationSpan.setAttribute("validation.errorCount", validation.errors.length), validationSpan.setAttribute("validation.preExistingErrorCount", report.preExistingErrors.length), validationSpan.setStatus({ code: 0 }), !validation.isValid()) {
+          result.validation.passed = !1, result.validation.errors = validation.errors.map((e) => e.message), emitLog(SeverityNumber.ERROR, "Validation failed", {
             "validation.errorCount": result.validation.errors.length,
             "validation.errors": result.validation.errors.slice(0, 10)
             // First 10 errors
-          }), new Error(`Validation failed with ${result.validation.errors.length} error(s):
+          });
+          const notes = [];
+          throw report.preExistingErrors.length > 0 && notes.push(`${report.preExistingErrors.length} pre-existing error(s) in the base model were not counted against this changeset.`), report.baseValidationFailure && notes.push(`The base model could not be validated (${report.baseValidationFailure}), so every error was counted.`), new Error(`Validation failed with ${result.validation.errors.length} error(s) introduced by this changeset:
 ` + result.validation.errors.map((e) => `  - ${e}`).join(`
-`) + `
+`) + (notes.length > 0 ? `
 
-Fix these validation errors before committing.`);
+${notes.join(`
+`)}` : "") + `
+
+Fix these validation errors before committing, or skip validation with --no-validate.`);
+        }
       }), isDryRun)
         return result.committed = changeset.changes.length, drift.isDrifted && (result.driftWarning = drift), result;
       let backup;
@@ -274,7 +381,18 @@ Fix these validation errors before committing.`);
       } catch (backupError) {
         throw new Error(`Failed to create backup before commit. No changes have been applied. ${backupError instanceof Error ? backupError.message : String(backupError)}`);
       }
-      const sortedChanges = [...changeset.changes].sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+      const sortedChanges = withSequenceNumbers(changeset.changes).sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+      let relationshipsPurged = !1;
+      model.getActiveChangesetId() !== null && (model.relationships = new Relationships(model.getBaseRelationships()));
+      let preCommitReportLayers = /* @__PURE__ */ new Set();
+      try {
+        preCommitReportLayers = reportLayersForChanges(new ModelReportOrchestrator(model, model.rootPath), model, sortedChanges);
+      } catch (error) {
+        emitLog(SeverityNumber.WARN, "Could not read report layers before changeset commit", {
+          "changeset.id": changesetId,
+          "error.message": getErrorMessage(error)
+        });
+      }
       try {
         const applySpan = isTelemetryEnabled ? startSpan("staging.apply", {
           "apply.changeCount": changeset.changes.length
@@ -309,19 +427,19 @@ Fix these validation errors before committing.`);
                     "change.layer": change.layerName
                   });
                 else {
-                  const element = new Element(elementData);
+                  const element = new Element(canonicalStagedSnapshot(elementData).data);
                   layer.addElement(element), result.committed++;
                 }
               } else if (change.type === "update" && change.after) {
                 const element = layer.getElement(change.elementId);
                 if (element) {
-                  const elementData = change.after;
-                  Object.assign(element, elementData), layer.updateElement(element), result.committed++;
+                  const { data: elementData, sourceReference } = canonicalStagedSnapshot(change.after);
+                  Object.assign(element, elementData), sourceReference.present && element.setSourceReference(sourceReference.value), layer.updateElement(element), result.committed++;
                 } else
                   result.failed++, result.validation.passed = !1, result.validation.errors.push(`Cannot update '${change.elementId}' in '${change.layerName}': element not found in base model`);
               } else if (change.type === "delete") {
-                const element = layer.getElement(change.elementId);
-                element ? (layer.deleteElement(element.path || element.id), result.committed++) : (result.skipped = (result.skipped ?? 0) + 1, result.skippedDetails = result.skippedDetails ?? [], result.skippedDetails.push(`'${change.elementId}' in '${change.layerName}' not found \u2014 already deleted`));
+                const element = layer.getElement(change.elementId), before = change.before ?? {};
+                model.relationships.deleteForElement(elementIdentifiers(element ?? before, before.id, before.path, change.elementId)) > 0 && (relationshipsPurged = !0), element ? (layer.deleteElement(element.path || element.id), result.committed++) : (result.skipped = (result.skipped ?? 0) + 1, result.skippedDetails = result.skippedDetails ?? [], result.skippedDetails.push(`'${change.elementId}' in '${change.layerName}' not found \u2014 already deleted`));
               } else
                 result.failed++, result.validation.passed = !1, result.validation.errors.push(`Cannot apply change '${change.type}' for '${change.elementId}': missing payload or unrecognised type`);
             } catch (error) {
@@ -346,7 +464,7 @@ Fix these validation errors before committing.`);
           } catch (error) {
             throw new Error(`Failed to save layer '${layerName}': ${getErrorMessage(error)}`);
           }
-        if (hasRelationshipChanges)
+        if (hasRelationshipChanges || relationshipsPurged)
           try {
             await model.saveRelationships();
           } catch (error) {
@@ -369,12 +487,10 @@ Fix these validation errors before committing.`);
           throw new Error(`Failed to save manifest with changeset history: ${manifestError instanceof Error ? manifestError.message : String(manifestError)}. Model will be rolled back to maintain consistency.`);
         }
         try {
-          const orchestrator = new ModelReportOrchestrator(model, model.rootPath), affectedLayers = /* @__PURE__ */ new Set();
-          for (const change of sortedChanges)
-            if (isValidLayerName(change.layerName))
-              for (const layer of orchestrator.computeAffectedLayers(change.layerName))
-                affectedLayers.add(layer);
-          await orchestrator.regenerate(affectedLayers);
+          const orchestrator = new ModelReportOrchestrator(model, model.rootPath), reportLayers = reportLayersForChanges(orchestrator, model, sortedChanges);
+          for (const layer of preCommitReportLayers)
+            reportLayers.add(layer);
+          await orchestrator.regenerate(reportLayers);
         } catch (error) {
           emitLog(SeverityNumber.WARN, "Failed to regenerate layer reports after changeset commit", {
             "changeset.id": changesetId,
@@ -996,6 +1112,32 @@ This indicates a filesystem or permissions issue. Check:
     return `changeset-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
   }
 }
+function layerOfId(id) {
+  const layer = id?.split(".")[0];
+  return layer && isValidLayerName(layer) ? layer : void 0;
+}
+function layerOfElement(model, id) {
+  if (!id)
+    return;
+  const element = model.getElementById(id);
+  return element?.layer_id || element?.layer || layerOfId(id);
+}
+function reportLayersForChanges(orchestrator, model, changes) {
+  const layers = /* @__PURE__ */ new Set(), add = (layer) => {
+    typeof layer == "string" && isValidLayerName(layer) && layers.add(layer);
+  };
+  for (const change of changes) {
+    if (change.type === "relationship-add" || change.type === "relationship-delete") {
+      const data = change.after ?? change.before ?? {}, [source, , target] = typeof data.source == "string" ? [data.source, data.predicate, data.target] : change.elementId.split("::");
+      add(change.layerName), add(data.layer), add(data.targetLayer), add(layerOfElement(model, source)), add(layerOfElement(model, target));
+      continue;
+    }
+    const snapshot = change.after ?? change.before ?? {}, element = model.getElementById(change.elementId), ids = elementIdentifiers(element ?? snapshot, change.elementId, element?.path || void 0);
+    for (const layer of orchestrator.computeElementAffectedLayers(change.layerName, ids))
+      layers.add(layer);
+  }
+  return layers;
+}
 export {
   StagingAreaManager
 };