@reqvire-org/ads 0.3.5 → 0.3.6

package/README.md

@@ -91,7 +91,11 @@ for config files and Claude Desktop setup.
 To let the agent edit the ADS through enforced checks, append `--mutations` to
 the MCP command. It accepts a Git patch for one ADS unit, including its owned scenarios and
 fixtures, and runs the guards before applying it. Foundation styles, original
-assets, guides and project configuration/guard extensions have editable units too. See [guarded editing](docs/MCP.md#guarded-editing).
+assets, guides and project configuration/guard extensions have editable units too.
+Coupled changes use bounded owner transactions with checks on the complete final
+candidate. Local owner drafts and token-sample preparation reduce patch setup;
+they keep source writes behind the same guards. See
+[guarded editing](docs/MCP.md#guarded-editing).
 
 The server exposes public components/patterns, token values,
 source guides, controllers/hooks, architecture checks, behavioral verification,

package/dist/bootstrap-ds/ADS.md

@@ -36,8 +36,14 @@ Projects sharing this ADS use the same token names, meanings, and value types;
 their concrete values and theme overrides can differ. Reuse existing local values
 when importing components/patterns, add missing shared definitions, and import
 source token values only when adopting that theme is requested.
-Token names and prefixes are fixed by ADS architecture; foreign brand prefixes
-are rejected. Shared assignments belong in token files. Components own
+Shared token names and prefixes follow the ADS contract. A component/pattern may
+register one unique local namespace in colocated `tokens.json` and define it in
+`tokens.css`, imported by its runtime. Flat owners use `<Owner>.tokens.json` and
+`<Owner>.tokens.css`. These definition-only sheets contain root/theme custom
+properties, not UI selectors or ordinary styles. Other owners consume shared
+tokens; they cannot override or consume a peer's local namespace. A colocated
+`kind:"tokens"` scenario needs real samples for every local token. Shared
+assignments remain in the shared token files. Components own
 `--ds-*`, patterns `--ux-*`, and the showcase `--showcase-*`; token files cannot
 assign those local variables or override component state.
 
@@ -183,7 +189,7 @@ mounting, correct props, every branch/state or visual parity. The older
 
 `token-scenario-reference` rejects undeclared token names in metadata and reachable
 inputs. `token-scenario-render` rejects claimed tokens with no reachable input
-reference; `token-scenario-coverage` requires every discovered foundation token
+reference; `token-scenario-coverage` requires every discovered shared or owner-local token
 to have coverage. A new or removed token therefore needs a scenario/fixture
 update. All three are errors in `ads check`, run by `lint:ds` and the build.
 Coverage is static reachability, not proof that every branch actually renders

package/dist/bootstrap-ds/README.md

@@ -62,6 +62,10 @@ the public `TokenPreview` pattern owns their presentation and applies the real C
 variables. Add/remove samples alongside token definitions. `ads check` rejects
 missing coverage and invented names; the App verifies the declared CSS bindings
 in the browser. Extend or replace the project-owned pattern as your tokens evolve.
+`ads_prepare_token_samples` can prepare a fixture patch from explicit project
+property/probe bindings. It preserves existing samples and reports unmapped tokens;
+it does not guess how a new value should look. Component/pattern constants can use
+the colocated namespace contract in [ADS.md](ADS.md), with their own token scenario.
 
 Create a component under `design-system/components/`, export it through `@ds`,
 and colocate `Scenario.tsx` plus `fixture.ts` (or `<Owner>.scenario.tsx` and
@@ -79,6 +83,8 @@ stale retained output. Switching or rebuilding a scenario unmounts its previous
 state. `showcase/mcp/main.tsx` exports `mountScenario(Scenario, container)` and
 returns an unmount callback; it is not the shell. Keep the saved `framework`,
 compiler and mount adapter consistent.
+Managed sessions own their graph output; standalone prebuilds cannot replace it.
+Verified generated graph snapshots preserve warm-start reuse across sessions.
 
 The application and previews use the same foundation CSS and Linaria pipeline.
 The source barrel loads the foundation once. The private `build:lib` script uses
@@ -98,3 +104,7 @@ from a user-selected external repository, preserving revisions and licenses.
 inspection builds it automatically, then loads selected entries. Browser review
 still checks layout, accessibility, keyboard/focus, states, themes and motion. A clean
 build or delivered HTML alone does not establish those behaviors.
+Opt-in MCP editing uses owner Git patches. `ads_prepare_patch` creates a temporary
+owner draft/diff; `ads_apply_transaction` validates bounded coupled owner patches
+against one final candidate. Preparation changes no live source. Keep all guards
+and review the rendered result after applying.

package/dist/boundaries.mjs

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { importedUiName } from "./ui-framework.mjs";
 import { isInside, isStateVariable, isTestFile, isDevelopmentFile } from "./config.mjs";
 import { isSharedToken } from "./token-policy.mjs";
+import { scopedTokenOwner } from "./scoped-tokens.mjs";
 
 export function projectCompilerOptions({ root }) {
   const file = ts.findConfigFile(root, ts.sys.fileExists, "tsconfig.json");
@@ -59,6 +60,8 @@ export function checkComponentVariable(name, filename, options) {
   const components = !development && isInside(path.join(dsRoot, "components"), filename);
   const patterns = !development && isInside(path.join(dsRoot, "patterns"), filename);
   const showcase = development;
+  const owned = scopedTokenOwner(options, name);
+  if (owned) return path.resolve(options.root, owned.file) === filename ? null : { rule: "token-ownership", message: `Define ${name} only in ${owned.file}, owned by ${owned.unit}. Consume it with var(); runtime geometry remains a separate styleWrites boundary.` };
   if (isSharedToken(name)) return tokens ? null : { rule: "token-ownership", message: `Define ${name} in ADS tokens, not component, pattern, showcase, or app styles.` };
   if (name.startsWith("--ux-")) return patterns || showcase ? null : { rule: "variable-ownership", message: "--ux-* variables belong to ADS patterns and showcase composition." };
   if (name.startsWith("--showcase-")) return showcase ? null : { rule: "variable-ownership", message: "--showcase-* variables belong to the ADS showcase." };

package/dist/check.mjs

@@ -18,6 +18,7 @@ import { inspectStyleBoundaries, pointerCaptureAdvisories } from "./style-bounda
 import { inspectBehaviors, inspectControllers } from "./behaviors.mjs";
 import { numericCssUnit, tokenLengthLiteral } from "./css-values.mjs";
 import { foundationDeclaration, foundationSelector } from "./foundation.mjs";
+import { scopedTokens, scopedTokenOwner } from "./scoped-tokens.mjs";
 
 const scenarioLayoutGuidance = "Put demo-only sizing and framing in a public review/layout pattern. Keep required behavior in the runtime owner; add component props for deliberate product API needs.";
 const inlineStyleGuidance = `Own visual styles in component/pattern Linaria. ${scenarioLayoutGuidance} Reserve inlineStyleFiles for documented measured geometry, not demo layout.`;
@@ -40,6 +41,8 @@ export function checkProject(directory, { trackingRoot } = {}) {
   diagnostics.push(...tokenInventory.diagnostics);
   diagnostics.push(...inspectAssets(options));
   const resolveImport = importResolver(options);
+  const scoped = scopedTokens(options);
+  const scopedFiles = new Set(scoped.definitions.map(entry => path.resolve(root, entry.file)));
   const rootHtml = path.join(root, "index.html");
   const files = [...new Set([...sourceFiles(sourceRoot), ...sourceFiles(dsRoot), ...(existsSync(rootHtml) ? [rootHtml] : [])])];
   const boundaryFiles = [...config.inlineStyleFiles, ...config.boundaries.styleWrites.map(entry => entry.file)].map(file => path.resolve(root, file)).filter(file => existsSync(file) && statSync(file).isFile());
@@ -110,6 +113,11 @@ export function checkProject(directory, { trackingRoot } = {}) {
       const variable = checkComponentVariable(decl.prop, file, options);
       if (variable) report(file, variable.rule, variable.message, offset.line + decl.source.start.line - 1, decl.source.start.column);
       for (const ref of references(decl.value)) {
+        const owned = scopedTokenOwner(options, ref.name);
+        if (owned) {
+          if (scoped.inventory.owner(scoped.inventory.relative(path.relative(root, file))) !== owned.unit || !declaredTokens.has(ref.name)) report(file, "token-reference", `${ref.name} belongs to ${owned.unit}. Use shared tokens across owners; owner-local tokens must be defined and consumed by their owner.`, offset.line + decl.source.start.line - 1, decl.source.start.column);
+          continue;
+        }
         const local = /^(?:--ds-|--ux-|--showcase-)/.test(ref.name);
         if (foundation && local) report(file, "foundation-role", "Foundation defaults consume shared tokens, not component, pattern or scenario-local variables.", offset.line + decl.source.start.line - 1, decl.source.start.column);
         if (!local && !isSharedToken(ref.name)) report(file, "token-name", `${ref.name} does not follow ADS's fixed token naming contract.`, offset.line + decl.source.start.line - 1, decl.source.start.column);
@@ -130,6 +138,7 @@ export function checkProject(directory, { trackingRoot } = {}) {
     });
   }
   for (const file of files) {
+    if (scopedFiles.has(file)) continue; // Closed definition-only contract checked by inspectTokens.
     if (file.endsWith(".css") && isInside(path.join(dsRoot, config.tokenDir), file) && !isDevelopmentFile(file, options)) { checkCss(file, readFileSync(file, "utf8"), undefined, true); continue; }
     if (file.endsWith(".html")) { inspectHtml(readFileSync(file, "utf8"), (rule, message, line) => report(file, rule, message, line)); continue; }
     if (file.endsWith(".css")) {
@@ -223,6 +232,10 @@ export function checkProject(directory, { trackingRoot } = {}) {
       if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) specifier = node.moduleSpecifier.text;
       if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments[0] && ts.isStringLiteral(node.arguments[0])) specifier = node.arguments[0].text;
       if (specifier && importViolation(specifier, file, options, resolveImport)) nodeReport(node, "public-import", `Import through ${config.publicAlias}, not ADS implementation paths.`);
+      if (specifier) for (const target of resolveImport(specifier, file)) {
+        const tokenOwner = scoped.definitions.find(entry => path.resolve(root, entry.file) === target);
+        if (tokenOwner && scoped.inventory.owner(scoped.inventory.relative(path.relative(root, file))) !== tokenOwner.unit) nodeReport(node, "token-ownership", `Only ${tokenOwner.unit} imports its token sheet. Import the public component/pattern to consume its design.`);
+      }
       if (specifier && resolveImport(specifier, file).some((target) => (specifier.startsWith(".") || existsSync(target)) && target.endsWith(".css") && isInside(root, target) && !isInside(dsRoot, target) && target !== path.join(sourceRoot, "app-mount.css") && !isInside(path.join(root, "node_modules"), target))) nodeReport(node, "style-ownership", "Imported project CSS belongs to ADS components, patterns, or the foundation. Only structural app-mount.css is allowed outside the ADS.");
       if (specifier && appImportViolation(specifier, file, options, resolveImport)) nodeReport(node, "no-app-import", "ADS implementations and showcase fixtures must not import app code. Use public ADS APIs with local fixture data; keep application integration harnesses in application tests.");
       if (specifier && showcaseImportViolation(specifier, file, options, resolveImport)) nodeReport(node, "showcase-import", "Showcase code and styles are development fixtures; runtime code must not import them.");

package/dist/config.mjs

@@ -152,10 +152,14 @@ export function isBehaviorFile(file) {
   return /(?:^|[\\/])behavior\.json$|\.behavior\.json$/.test(file);
 }
 
+export function isTokenManifestFile(file) {
+  return /(?:^|[\\/])tokens\.json$|\.tokens\.json$/.test(file);
+}
+
 export function isDevelopmentFile(file, { dsRoot }) {
   if (!isInside(dsRoot, file)) return isTestFile(file);
   const relative = path.relative(dsRoot, file).replaceAll("\\", "/");
-  return isTestFile(file) || isScenarioFile(file) || isFixtureFile(file) || isBehaviorFile(file)
+  return isTestFile(file) || isScenarioFile(file) || isFixtureFile(file) || isBehaviorFile(file) || isTokenManifestFile(file)
     || /^(?:showcase|composition)\//.test(relative)
     || /(?:^|\/)(?:scenario|fixtures)(?:\/|$)/.test(relative)
     || /\.scenario(?:-adapter)?\.[cm]?[jt]sx?$/.test(relative);
@@ -170,7 +174,7 @@ export function sourceFiles(root) {
     if (ignored.has(entry.name) || entry.isSymbolicLink()) continue;
     const file = path.join(root, entry.name);
     if (entry.isDirectory()) files.push(...sourceFiles(file));
-    else if (entry.isFile() && (/\.(css|html|[cm]?[jt]sx?)$/.test(entry.name) || isBehaviorFile(entry.name))) files.push(file);
+    else if (entry.isFile() && (/\.(css|html|[cm]?[jt]sx?)$/.test(entry.name) || isBehaviorFile(entry.name) || isTokenManifestFile(entry.name))) files.push(file);
   }
   return files.sort();
 }

package/dist/mcp/build-status.mjs

@@ -4,6 +4,7 @@ import path from "node:path";
 import { z } from "zod";
 import { isInside, projectPath } from "../config.mjs";
 import { readPreviewManifest } from "../preview-resources.mjs";
+import { previewArtifactPath, withPreviewSession } from "../preview-scope.mjs";
 
 export const BUILD_URI = "ads://project/build";
 export const buildStatusFile = (root) => path.join(root, ".ds/build-status.json");
@@ -123,7 +124,8 @@ export function createBuildReporter(directory, { apps, session = process.env.ADS
 }
 
 /** Read durable build events; a running process alone never means a fresh build. */
-export function inspectBuildStatus(root, config, { session, processState, file = buildStatusFile(root) } = {}) {
+export function inspectBuildStatus(root, config, { session, previewSession, processState, file = buildStatusFile(root) } = {}) {
+  const options = withPreviewSession({ root, config: { mcp: config } }, previewSession);
   let report;
   let reportError;
   try {
@@ -137,7 +139,7 @@ export function inspectBuildStatus(root, config, { session, processState, file =
   let graphError;
   if (config.previewManifest && report?.previews.some(entry => entry.state === "ready")) {
     try {
-      if (!readPreviewManifest({ root, config: { mcp: config } }, { verify: true })) throw new Error("Preview resource manifest is missing.");
+      if (!readPreviewManifest(options, { verify: true })) throw new Error("Preview resource manifest is missing.");
     } catch (error) { graphError = `Invalid preview resource graph: ${error.message}`; }
   }
   const previews = config.apps.map((app) => {
@@ -145,12 +147,13 @@ export function inspectBuildStatus(root, config, { session, processState, file =
     let state = value?.state ?? "unreported";
     let diagnostics = value?.diagnosticSet !== undefined ? report.diagnosticSets[value.diagnosticSet] : value?.diagnostics ?? [];
     if (report?.diagnostics?.length) { state = "error"; diagnostics = [...report.diagnostics, ...diagnostics].slice(0, 20); }
-    const available = existsSync(path.resolve(root, app.file));
+    const artifact = path.resolve(root, previewArtifactPath(options, app.file));
+    const available = existsSync(artifact);
     if (reportError) { state = "error"; diagnostics = [{ message: reportError }]; }
     if (graphError && app.id.includes("/")) { state = "error"; diagnostics = [{ message: graphError }]; }
     if (state === "ready") {
       try {
-        if (value.lastSuccessfulRevision !== value.revision || artifactDigest(path.resolve(root, app.file)) !== value.artifactDigest) throw new Error("Preview output does not match its successful build. Rebuild before reviewing it.");
+        if (value.lastSuccessfulRevision !== value.revision || artifactDigest(artifact) !== value.artifactDigest) throw new Error("Preview output does not match its successful build. Rebuild before reviewing it.");
       } catch (error) { state = "error"; diagnostics = [{ message: error.message }]; }
     }
     if (processState?.state === "failed") { state = "error"; diagnostics = [{ message: processState.error ?? "Preview watcher exited." }, ...diagnostics].slice(0, 20); }

package/dist/mcp/context.mjs

@@ -5,7 +5,7 @@ import { projectGuideFiles } from "../project-documents.mjs";
 
 export const GUIDE_URI = "ads://project/guide";
 // Put the task triggers and entry path first: some hosts shorten server guidance.
-export const serverInstructions = "Use ADS for UI work: components, patterns, controllers, hooks, tokens, themes, branding, layout, interaction, accessibility, motion and showcase review. Start with ads_status; if tools are not exposed, read ads://project/guide then ads://project/status. Use the returned projectRoot and commands. When ads_status.mutations.enabled, use ads_units and guarded ads_apply_patch for one owner at a time. Find existing public UI with ads_catalog; discover its previews with ads_scenarios and open ads_show_scenario. Starting ADS also serves its built-in showcase: use ads_status.showcaseUrl for browser review instead of starting another runtime/compiler or project browser app. Read one relevant ADS skill before editing. Inspect the real preview, edit its owned source, check the build and review again. Scope source/guides to the project, its instruction ancestry and user-selected import/reference sources; broad searches of /mnt or home are not ADS discovery. Domain-model/requirements work is a separate project workflow. For behavior work, read ads://guides/behaviors and use ads_behaviors/ads_verify: scenario exercises are demonstrations, and registered guarantees need current passing execution evidence. Use the configured project framework and declared dependencies; MCP hosts supply no ad hoc APIs. MCP source checks do not replace browser tests; direct edits still need project checks. Reading HTML is not rendering, and reading a skill is not native activation. A running watcher is not proof of current source: inspect ads_status.build or ads://project/build after edits. Notifications may not reach the agent. Only explicitly enabled mutation tools edit project-owned ADS units after validation. Checks and compiler commands come from validated project configuration, never an ad hoc command argument.";
+export const serverInstructions = "Use ADS for UI work: components, patterns, controllers, hooks, tokens, themes, branding, layout, interaction, accessibility, motion and showcase review. Start with ads_status; if tools are not exposed, read ads://project/guide then ads://project/status. Use the returned projectRoot and commands. When ads_status.mutations.enabled, use ads_units and guarded ads_apply_patch for one owner; use ads_apply_transaction only for coupled owner patches. Find existing public UI with ads_catalog; discover its previews with ads_scenarios and open ads_show_scenario. Starting ADS also serves its built-in showcase: use ads_status.showcaseUrl for browser review instead of starting another runtime/compiler or project browser app. Read one relevant ADS skill before editing. Inspect the real preview, edit its owned source, check the build and review again. Scope source/guides to the project, its instruction ancestry and user-selected import/reference sources; broad searches of /mnt or home are not ADS discovery. Domain-model/requirements work is a separate project workflow. For behavior work, read ads://guides/behaviors and use ads_behaviors/ads_verify: scenario exercises are demonstrations, and registered guarantees need current passing execution evidence. Use the configured project framework and declared dependencies; MCP hosts supply no ad hoc APIs. MCP source checks do not replace browser tests; direct edits still need project checks. Reading HTML is not rendering, and reading a skill is not native activation. A running watcher is not proof of current source: inspect ads_status.build or ads://project/build after edits. Notifications may not reach the agent. Only explicitly enabled mutation tools edit project-owned ADS units after validation. Checks and compiler commands come from validated project configuration, never an ad hoc command argument.";
 
 function manager(root, pkg) {
   if (typeof pkg.packageManager === "string") return pkg.packageManager.split("@")[0];
@@ -56,7 +56,7 @@ Use this server for UI components/patterns, tokens/themes/branding, layout, inte
 3. Select one workflow with ads_skills, then ads_read_skill. ${route.skills.map((skill) => `${skill.task}: ${skill.name}`).join("; ")}. Native skill activation is host-controlled. Relative skill references resolve from its SKILL.md URI. Read support files only when relevant.
 4. ${route.preview} Token samples: ads_scenarios(kind: tokens), then ads_show_scenario or ads_show_tokens(category: id). Token source inspection: ads_tokens with a focused query. Registered previews: ${previews.map((preview) => `${preview.id}: ${preview.tool ?? "ads_show_scenario"}`).join(", ") || "none"}. Showcase URL: ${context.showcase.url ?? "not configured; use the project's showcase command"}.
    Inspection connects a public export to its owning source, available guides, token values and discovered preview IDs. Bounded tools keep discovery focused; explicit resource reads supply detail. Source metadata does not prove layout, interaction or motion. A scenario renders the real public implementation and its fixture context in either review surface.
-5. Check ads_status.mutations. When enabled, discover one owner with ads_units, read relevant source ranges with ads_read_file and submit only a Git unified diff through ads_apply_patch({unit, patch, dryRun}). Include that owner's scenarios, fixtures and required public re-exports, never peer units. tokens is the foundation unit; its manifest lists companionFiles for required canonical foundation imports when token files are created/deleted in the same patch. Preserve unrelated imports/comments and public-entry statements, including export {};. Dry-run to inspect validation; apply only a passing patch. Fix rejected patches in the owning unit; report unsupported coupled changes instead of bypassing rejection with direct writes. Intentional project setup, registered guard/compiler code and exceptions use configuration; shared globals use foundation, guides documentation and assets their discovered assets/* unit. Keep mandatory ADS gates. Binary/large Git diffs may use patchFile under .ds/patches/ to avoid model-context bytes. In read-only mode, source edits use the client editor/filesystem tools. Reuse the local public API (${context.publicEntry}). Edit presentation in its ADS owner; keep application data/services/routing in application code and development fixtures beside their scenario; larger scenarios live in composition/. Linaria extracts owned styling. Inspect relevant tokens with ads_tokens and source/owning guides before edits.
+5. Check ads_status.mutations. When enabled, discover one owner with ads_units, read relevant source ranges with ads_read_file and submit only a Git unified diff through ads_apply_patch({unit, patch, dryRun}). Include that owner's scenarios, fixtures and required public re-exports, never peer units. tokens is the foundation unit; its manifest lists companionFiles for required canonical foundation imports when token files are created/deleted in the same patch. Preserve unrelated imports/comments and public-entry statements; a real selected-owner re-export can remove its redundant export {};. Dry-run to inspect validation; apply only a passing patch. Fix rejected patches in the owning unit; use ads_apply_transaction for coupled owners instead of bypassing rejection with direct writes. ads_prepare_patch creates a local owner draft/diff; ads_prepare_token_samples reconciles explicit project bindings without guessing visual meaning. Intentional project setup, registered guard/compiler code and exceptions use configuration; shared globals use foundation, guides documentation and assets their discovered assets/* unit. Keep mandatory ADS gates. Binary/large Git diffs may use patchFile under .ds/patches/ to avoid model-context bytes. In read-only mode, source edits use the client editor/filesystem tools. Reuse the local public API (${context.publicEntry}). Edit presentation in its ADS owner; keep application data/services/routing in application code and development fixtures beside their scenario; larger scenarios live in composition/. Linaria extracts owned styling. Inspect relevant tokens with ads_tokens and source/owning guides before edits.
 6. ${route.validation} Registered commands: ${context.commands.map((command) => command.args?.join(" ") ?? `choose the project package manager for ${command.script}`).join("; ") || "none discovered; inspect the project's build setup"}. Run them from ${context.projectRoot}.
 7. After edits, inspect ads_status.build or ads://project/build explicitly. Running/unreported/old output is not a current successful preview. Fix diagnostics in owned source, wait for rebuilding and invoke the preview tool again. Notifications may not start an agent turn.
 

package/dist/mcp/edit-preparation.mjs

@@ -0,0 +1,111 @@
+import { createHash, randomUUID } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { isInside } from "../config.mjs";
+import { checkUnitFiles, inspectUnits, validateUnitId } from "../units.mjs";
+import { textDiff } from "./text-diff.mjs";
+
+const hash = value => createHash("sha256").update(value).digest("hex");
+const binary = bytes => bytes?.includes(0) || bytes && !Buffer.from(bytes.toString("utf8")).equals(bytes);
+function generated(options, relative) {
+  const target = path.join(options.root, ".ds", relative);
+  mkdirSync(path.dirname(target), {recursive:true});
+  if (realpathSync(path.dirname(target)) !== path.dirname(target)) throw new Error("Patch preparation output cannot resolve through symlinks.");
+  return target;
+}
+export function storePreparedPatch(options, patch) {
+  if (Buffer.byteLength(patch) > 16 * 1024 * 1024) throw new Error("Prepared Git patch exceeds 16 MiB.");
+  if (!patch) return {patch:null,patchFile:null};
+  const file = `.ds/patches/${randomUUID()}.patch`;
+  writeFileSync(generated(options,file.slice(4)),patch);
+  return {patchFile:file,bytes:Buffer.byteLength(patch)};
+}
+
+/** A temporary copy of just one owner and its declared companions, not a project mirror. */
+export function prepareUnitPatch(options, {unit, action = "create", draft}) {
+  validateUnitId(unit);
+  const inventory = inspectUnits(options);
+  if (action === "create") {
+    const owner = inventory.units.find(entry => entry.id === unit);
+    const files = [...new Set([...(owner?.files ?? []), ...(owner?.companionFiles ?? []).map(entry => entry.path),
+      ...(!owner ? ["ds.config.json"] : []),
+      ...(/^(?:components|patterns|controllers)\//.test(unit) ? [path.relative(options.root,path.join(options.dsRoot,options.config.publicEntry)).replaceAll("\\","/")] : [])])];
+    if (!owner && !/^(?:components|patterns|controllers|composition)\/.+/.test(unit)) throw new Error("Discover an existing unit or choose a new unoccupied component/pattern/controller/composition owner.");
+    if (/^(?:components|patterns|controllers|composition)\//.test(unit)) for (let directory=unit;directory!==".";directory=path.posix.dirname(directory)) {
+      const marker=path.join(options.dsRoot,directory,".gitkeep");
+      if (existsSync(marker) && realpathSync(marker)===marker && lstatSync(marker).isFile() && lstatSync(marker).size===0) {
+        const relative=path.relative(options.root,marker).replaceAll("\\","/");
+        if (!files.includes(relative)) files.push(relative);
+      }
+    }
+    draft = randomUUID();
+    const base = generated(options,`patch-drafts/${draft}/manifest.json`), folder = path.join(path.dirname(base),"work");
+    const entries = [];
+    let bytes = 0;
+    for (const file of files) {
+      const absolute = path.resolve(options.root,file);
+      if (!isInside(options.root,absolute) || realpathSync(absolute) !== absolute || !lstatSync(absolute).isFile()) throw new Error("Draft inputs must be ordinary project source files.");
+      if (lstatSync(absolute).size > 16 * 1024 * 1024) throw new Error("Draft input exceeds 16 MiB.");
+      const content = readFileSync(absolute);
+      bytes += content.length;
+      if (entries.length >= 256 || bytes > 32 * 1024 * 1024) throw new Error("Owner draft exceeds 256 files/32 MiB. Prepare a targeted Git patch instead.");
+      for (const name of ["work","base"]) {
+        const target = path.join(path.dirname(base),name,file);
+        mkdirSync(path.dirname(target),{recursive:true}); writeFileSync(target,content);
+      }
+      entries.push({file,digest:hash(content)});
+    }
+    mkdirSync(folder,{recursive:true});
+    writeFileSync(base,JSON.stringify({schemaVersion:1,unit,entries}));
+    return {draft,unit,directory:folder,files, next:"Edit only this draft, then call ads_prepare_patch with action: diff and this draft ID. Live source is unchanged; the resulting Git patch still requires ads_apply_patch and all its gates."};
+  }
+  if (!/^[a-f0-9-]{36}$/.test(draft ?? "")) throw new Error("Use the draft ID returned by ads_prepare_patch.");
+  const base = path.join(options.root,".ds/patch-drafts",draft);
+  if (realpathSync(base) !== base) throw new Error("Draft paths cannot resolve through symlinks.");
+  const metadata = JSON.parse(readFileSync(path.join(base,"manifest.json"),"utf8"));
+  if (metadata.schemaVersion !== 1 || metadata.unit !== unit) throw new Error("Draft and selected unit do not match.");
+  if (action === "discard") {rmSync(base,{recursive:true});return {discarded:true,draft,unit};}
+  if (action !== "diff") throw new Error("Choose create, diff or discard.");
+  const files = new Set(metadata.entries.map(entry => entry.file));
+  function walk(directory) {
+    if (realpathSync(directory) !== directory) throw new Error("Draft directories cannot resolve through symlinks.");
+    for (const entry of readdirSync(directory,{withFileTypes:true})) {
+      const file = path.join(directory,entry.name);
+      if (entry.isDirectory()) walk(file);
+      else if (!entry.isFile() || lstatSync(file).nlink !== 1) throw new Error("Drafts contain ordinary unlinked source files only.");
+      else files.add(path.relative(path.join(base,"work"),file).replaceAll("\\","/"));
+      if (files.size > 256) throw new Error("Draft exceeds 256 files.");
+    }
+  }
+  walk(path.join(base,"work"));
+  const changes = [];
+  let patch = "", bytes = 0;
+  for (const file of files) {
+    if (!file || path.isAbsolute(file) || file.includes("\\") || file.split("/").some(part => !part || part === "." || part === ".." || part.startsWith(".") && part !== ".gitkeep" && !/^\.(?:oxlintrc|linariarc|babelrc)(?:\.json)?$/.test(part))) throw new Error("Drafts use ordinary project-relative source paths.");
+    const original = path.join(base,"base",file), next = path.join(base,"work",file), live = path.join(options.root,file);
+    const read = file => {
+      if (!existsSync(file)) return null;
+      const stat = lstatSync(file);
+      if (realpathSync(file) !== file || !stat.isFile() || stat.nlink !== 1 || stat.size > 16 * 1024 * 1024) throw new Error("Draft inputs must be ordinary unlinked files no larger than 16 MiB.");
+      return readFileSync(file);
+    };
+    const expected = metadata.entries.find(entry => entry.file === file)?.digest ?? null;
+    const left = read(original), right = read(next), source = read(live);
+    if ((left && hash(left)) !== expected || (source && hash(source)) !== expected) throw new Error(`Source/baseline changed for ${file}; create a fresh owner draft.`);
+    if (left !== null && right !== null && left.equals(right) || left === null && right === null) continue;
+    bytes += (left?.length ?? 0) + (right?.length ?? 0);
+    if (bytes > 32 * 1024 * 1024) throw new Error("Draft changes exceed 32 MiB.");
+    const change = {path:file,originalContent:left === null ? null : binary(left) ? left : left.toString(),content:right === null ? null : binary(right) ? right : right.toString()};
+    changes.push(change);
+    if (!binary(left) && !binary(right)) patch += textDiff(file,change.originalContent,change.content);
+    else {
+      let diff;
+      try { diff = execFileSync("git",["diff","--no-index","--binary","--no-ext-diff","--no-textconv","--",left === null ? "/dev/null" : original,right === null ? "/dev/null" : next],{encoding:"utf8",maxBuffer:16*1024*1024}); }
+      catch (error) { if (error.status !== 1) throw error; diff=error.stdout; }
+      patch += diff.replace(/^diff --git .+$/m,`diff --git a/${file} b/${file}`);
+    }
+  }
+  if (changes.length) checkUnitFiles(options,unit,changes,inventory,true);
+  return {unit,draft,changes:changes.map(entry=>entry.path),...storePreparedPatch(options,patch),next:"Apply with ads_apply_patch using this unit and patchFile. Preparation is not validation or publication."};
+}

package/dist/mcp/mutations.mjs

@@ -13,7 +13,7 @@ import { projectContext } from "./context.mjs";
 import { applyFilePatch, parseUnifiedPatch } from "./patch.mjs";
 import { checkUnitCandidate, checkUnitFiles, inspectUnits, validateUnitId } from "../units.mjs";
 
-export const mutationLimits = { files: 32, patchBytes: 256 * 1024, patchFileBytes: 16 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, readChars: 12000, snapshotFiles: 20000, snapshotBytes: 128 * 1024 * 1024 };
+export const mutationLimits = { units: 8, files: 32, patchBytes: 256 * 1024, patchFileBytes: 16 * 1024 * 1024, fileBytes: 16 * 1024 * 1024, readChars: 12000, snapshotFiles: 20000, snapshotBytes: 128 * 1024 * 1024 };
 const digest = bytes => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
 const ignored = new Set([".git", ".ds", "node_modules", ".vite", "coverage", ".playwright-cli", "test-results", "output"]);
 const textFile = file => /\.(?:[cm]?[jt]sx?|css|html|jsonc?|md|txt|svg)$/.test(file);
@@ -29,7 +29,7 @@ function address(options, file) {
   if (!isInside(options.root, target) || target === options.root) throw fail("mutation-path", "Mutation paths must stay inside the project.", file);
   for (let current = options.root; ; ) {
     const relative = path.relative(current, target).split(path.sep);
-    if (relative.some(part => ignored.has(part) || part.startsWith(".") && !setupDotfile(part))) throw fail("mutation-path", "Hidden, dependency and generated paths are not editable.", file);
+    if (relative.some(part => ignored.has(part) || part.startsWith(".") && !setupDotfile(part) && !(part === ".gitkeep" && path.basename(target) === part && isInside(options.dsRoot, target)))) throw fail("mutation-path", "Hidden, dependency and generated paths are not editable.", file);
     current = path.join(current, relative[0]);
     const stat = lstatSync(current, { throwIfNoEntry: false });
     if (stat?.isSymbolicLink() || stat && current !== target && !stat.isDirectory() || stat && current === target && (!stat.isFile() || stat.nlink !== 1)) throw fail("mutation-path", "Mutation paths must contain ordinary directories and unlinked regular files.", file);
@@ -154,7 +154,7 @@ export function createMutationController(directory) {
       let commands = [], diagnostics = [];
       try { commands = checks(options).map(check => [check.command, ...check.args].join(" ")); }
       catch (error) { diagnostics = [error.diagnostic ?? { rule: "mutation-check", message: error.message }]; }
-      return { enabled: true, scope: "one-ds-unit", format: "git-unified-diff", dsDir: options.config.dsDir, limits: mutationLimits, checks: ["ads check", "registered Oxlint rules", ...commands], diagnostics, busy, lastResult };
+      return { enabled: true, scope: "one-ds-unit", format: "git-unified-diff", transactions:{tool:"ads_apply_transaction",maxUnits:mutationLimits.units,finalCandidateChecks:true}, preparation:{owner:"ads_prepare_patch",tokenSamples:"ads_prepare_token_samples"}, dsDir: options.config.dsDir, limits: mutationLimits, checks: ["ads check", "registered Oxlint rules", ...commands], diagnostics, busy, lastResult };
     },
     cancel() { active?.abort(); },
     units() { return inspectUnits(loadConfig(root)).units; },
@@ -170,7 +170,7 @@ export function createMutationController(directory) {
       return { ...source, unit, content, offset, nextOffset: end < source.content.length ? end : null, totalChars: source.content.length,
         startLine: source.content.slice(0, offset).split("\n").length };
     },
-    async apply({ unit, patch, patchFile, dryRun = false }, signal) {
+    async apply({ unit, patch, patchFile, patches, dryRun = false }, signal) {
       if (busy) return { ok: false, applied: false, diagnostics: [{ rule: "mutation-busy", message: "Another mutation is validating; retry after it finishes." }] };
       busy = true;
       active = new AbortController();
@@ -179,26 +179,22 @@ export function createMutationController(directory) {
       const verified = [];
       try {
         const options = loadConfig(root);
-        validateUnitId(unit);
-        if ((typeof patch === "string") === (typeof patchFile === "string")) throw fail("mutation-patch", "Provide exactly one of patch or patchFile.");
-        const maxPatch = patchFile === undefined ? mutationLimits.patchBytes : mutationLimits.patchFileBytes;
-        if (patchFile !== undefined) patch = readPatchFile(options, patchFile);
-        if (typeof patch !== "string" || patch.includes("\0") || Buffer.from(patch).toString("utf8") !== patch || Buffer.byteLength(patch) > maxPatch) throw fail("mutation-patch", "Patch exceeds its UTF-8 Git diff size limit.");
-        const entries = parseUnifiedPatch(patch, mutationLimits.files), changes = [];
-        const originals = entries.map(entry => {
-          const change = { path: entry.path };
-          const target = address(options, change.path);
-          const before = read(options, change.path);
-          if (!entry.binary && before.binary) throw fail("mutation-patch", "Binary assets require a git diff --binary patch.", change.path);
-          change.content = entry.binary ? entry.operation === "delete" ? null : before.content ?? Buffer.alloc(0) : applyFilePatch(entry, before.content);
-          if (entry.binary) change.binaryPatch = entry.patch;
-          change.expectedDigest = before.digest;
-          change.originalContent = before.content;
-          if (!entry.binary) validateContent(change, unit);
-          changes.push(change);
-          return { ...before, mode: before.exists ? lstatSync(target).mode : undefined };
+        if (patches !== undefined && (unit !== undefined || patch !== undefined || patchFile !== undefined || !Array.isArray(patches) || patches.length < 2 || patches.length > mutationLimits.units)) throw fail("mutation-batch", "A transaction requires 2–8 distinct owner patches, without a top-level unit/patch.");
+        const groups = patches ?? [{unit,patch,patchFile}];
+        if (new Set(groups.map(group => group.unit)).size !== groups.length) throw fail("mutation-batch", "Use one patch per distinct unit in a transaction.");
+        let patchBytes = 0;
+        const plans = groups.map(group => {
+          validateUnitId(group.unit);
+          if ((typeof group.patch === "string") === (typeof group.patchFile === "string")) throw fail("mutation-patch", "Provide exactly one of patch or patchFile for each owner.");
+          const value = group.patchFile === undefined ? group.patch : readPatchFile(options,group.patchFile);
+          const maxPatch = group.patchFile === undefined ? mutationLimits.patchBytes : mutationLimits.patchFileBytes;
+          patchBytes += Buffer.byteLength(value ?? "");
+          if (typeof value !== "string" || value.includes("\0") || Buffer.from(value).toString("utf8") !== value || Buffer.byteLength(value) > maxPatch || patchBytes > mutationLimits.patchFileBytes) throw fail("mutation-patch", "Patch exceeds its UTF-8 Git diff size limit.");
+          return {unit:group.unit,entries:parseUnifiedPatch(value,mutationLimits.files)};
         });
-        const inventory = checkUnitFiles(options, unit, changes, inspectUnits(options), true);
+        const units = groups.map(group => group.unit), configuration = units.includes("configuration"), assets = units.some(unit => unit.startsWith("assets"));
+        for (const plan of plans) for (const entry of plan.entries) address(options,entry.path);
+        const changes = [], originals = [], byPath = new Map();
         const cache = path.join(root, ".ds");
         mkdirSync(cache, { recursive: true });
         if (realpathSync(cache) !== path.join(realpathSync(root), ".ds")) throw fail("mutation-path", "The .ds directory cannot resolve through a symlink.");
@@ -206,7 +202,6 @@ export function createMutationController(directory) {
         const candidate = path.join(temporary, "project");
         mkdirSync(candidate);
         const before = snapshot(options, candidate);
-        for (const original of originals) if (read(options, original.path).digest !== original.digest) throw fail("mutation-conflict", "Source changed while preparing the validation copy. Read the affected range and regenerate the patch.", original.path);
         const dependencies = path.join(root, "node_modules");
         if (!existsSync(dependencies)) throw fail("mutation-check", "Install project dependencies before using guarded mutations.");
         symlinkSync(realpathSync(dependencies), path.join(candidate, "node_modules"), process.platform === "win32" ? "junction" : "dir");
@@ -222,24 +217,45 @@ export function createMutationController(directory) {
             return true;
           } });
         }
+        const entries = plans.flatMap(plan => plan.entries);
         if (entries.some(entry => entry.binary)) {
           const formats = new Set(entries.filter(entry=>entry.binary).map(entry=>entry.objectFormat));
           if (formats.size !== 1) throw fail("mutation-patch", "Binary blocks in one Git diff must use the same object format.");
           await checkCommand("git", ["init", "--quiet", `--object-format=${[...formats][0]}`, candidate], root, signal);
         }
-        for (const change of changes) {
-          const file = path.join(candidate, change.path);
-          if (change.binaryPatch) {
-            for (const match of change.binaryPatch.matchAll(/^(?:literal|delta) (\d+)$/gm)) if (Number(match[1]) > mutationLimits.fileBytes) throw fail("mutation-content", "Binary patch blocks exceed 16 MiB.", change.path);
-            await checkCommand("git", ["apply", "--binary", "--whitespace=nowarn", "-"], candidate, signal, change.binaryPatch);
-            change.content = existsSync(file) ? readFileSync(file) : null;
-            validateContent(change, unit);
+        for (const plan of plans) {
+          const current = loadConfig(candidate), selected = plan.entries.map(entry => {
+            address(options,entry.path);
+            const before = read(current,entry.path);
+            if (!entry.binary && before.binary) throw fail("mutation-patch", "Binary assets require a git diff --binary patch.", entry.path);
+            const change = {path:entry.path, originalContent:before.content, content:entry.binary ? entry.operation === "delete" ? null : before.content ?? Buffer.alloc(0) : applyFilePatch(entry,before.content), ...(entry.binary ? {binaryPatch:entry.patch} : {})};
+            if (!entry.binary) validateContent(change,plan.unit);
+            if (!byPath.has(entry.path)) {
+              const original = read(options,entry.path);
+              // The candidate copy and live inputs must agree before any changes.
+              if (original.digest !== before.digest) throw fail("mutation-conflict", "Source changed while preparing validation; regenerate the patch.", entry.path);
+              originals.push({...original,mode:original.exists ? lstatSync(address(options,entry.path)).mode : undefined});
+              byPath.set(entry.path,changes.length);
+              changes.push({...change,expectedDigest:original.digest});
+              if (changes.length > mutationLimits.files) throw fail("mutation-batch", "A transaction may change at most 32 distinct files.");
+            }
+            return change;
+          });
+          const inventory = checkUnitFiles(current,plan.unit,selected,inspectUnits(current),true);
+          for (const change of selected) {
+            const file = path.join(candidate,change.path);
+            if (change.binaryPatch) {
+              for (const match of change.binaryPatch.matchAll(/^(?:literal|delta) (\d+)$/gm)) if (Number(match[1]) > mutationLimits.fileBytes) throw fail("mutation-content", "Binary patch blocks exceed 16 MiB.", change.path);
+              await checkCommand("git",["apply","--binary","--whitespace=nowarn","-"],candidate,signal,change.binaryPatch);
+              change.content = existsSync(file) ? readFileSync(file) : null;
+              validateContent(change,plan.unit);
+            } else if (change.content === null) rmSync(file);
+            else {mkdirSync(path.dirname(file),{recursive:true});writeFileSync(file,change.content);}
+            changes[byPath.get(change.path)].content = change.content;
           }
-          else if (change.content === null) rmSync(file);
-          else { mkdirSync(path.dirname(file), { recursive: true }); writeFileSync(file, change.content); }
+          checkUnitCandidate(loadConfig(candidate),plan.unit,selected,inventory);
         }
         const candidateOptions = loadConfig(candidate);
-        checkUnitCandidate(candidateOptions, unit, changes, inventory);
         const extraChecks = checks(candidateOptions);
         const expected = snapshot(candidateOptions);
         const result = checkProject(candidate, { trackingRoot: root });
@@ -251,12 +267,12 @@ export function createMutationController(directory) {
         const bin = JSON.parse(readFileSync(oxlintPackage, "utf8")).bin;
         const executable = path.resolve(path.dirname(oxlintPackage), typeof bin === "string" ? bin : bin.oxlint);
         const lintPaths = [candidateOptions.config.sourceDir, candidateOptions.config.dsDir].filter(file => existsSync(path.join(candidate, file)));
-        if (unit === "configuration") for (const file of inspectUnits(candidateOptions).units.find(item => item.id === "configuration").files) {
+        if (configuration) for (const file of inspectUnits(candidateOptions).units.find(item => item.id === "configuration").files) {
           if (/\.[cm]?[jt]sx?$/.test(file) && !lintPaths.some(directory => isInside(path.resolve(candidate, directory), path.resolve(candidate, file)))) lintPaths.push(file);
         }
         await checkCommand(process.execPath, [executable, "--deny-warnings", "--config", lintConfig, ...lintPaths], candidate, signal);
         verified.push({ name: "registered Oxlint rules", passed: true });
-        if (unit.startsWith("assets") || unit === "configuration") {
+        if (assets || configuration) {
           const brand = await generateBrandAssets(candidate);
           verified.push({ name: "brand assets", passed: true, skipped: !!brand.skipped });
         }
@@ -300,8 +316,8 @@ export function createMutationController(directory) {
           }
         }
         const warnings = [];
-        if (!dryRun && (unit.startsWith("assets") || unit === "configuration")) { try { await generateBrandAssets(root); } catch (error) { warnings.push({ rule: "mutation-assets", message: `Source was applied; generated brand output needs recovery: ${error.message}` }); } }
-        return lastResult = { ok: true, unit, applied: !dryRun, changes: changes.map(change => ({ path: change.path, operation: change.content === null ? "delete" : change.expectedDigest === null ? "create" : "update", digest: change.content === null ? null : digest(Buffer.from(change.content)) })), checks: verified, ...(result.advisories?.length ? { advisories: result.advisories.slice(0, 50), advisoryCount: result.advisories.length } : {}), ...(warnings.length ? { warnings } : {}),
+        if (!dryRun && (assets || configuration)) { try { await generateBrandAssets(root); } catch (error) { warnings.push({ rule: "mutation-assets", message: `Source was applied; generated brand output needs recovery: ${error.message}` }); } }
+        return lastResult = { ok: true, ...(patches ? {units,transaction:true} : {unit}), applied: !dryRun, changes: changes.map(change => ({ path: change.path, operation: change.content === null ? "delete" : change.expectedDigest === null ? "create" : "update", digest: change.content === null ? null : digest(Buffer.from(change.content)) })), checks: verified, ...(result.advisories?.length ? { advisories: result.advisories.slice(0, 50), advisoryCount: result.advisories.length } : {}), ...(warnings.length ? { warnings } : {}),
           preview: "Source validation passed. Inspect the managed preview build and rendered scenario after applying; validation is not visual verification." };
       } catch (error) {
         return lastResult = { ok: false, applied: false, diagnostics: [error.diagnostic ?? { rule: "mutation-error", message: error.message }], checks: verified };

package/dist/mcp/preview-watch.mjs

@@ -4,6 +4,7 @@ import { statSync, mkdirSync, writeFileSync, renameSync, rmSync, realpathSync }
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildFailure, inspectBuildStatus } from "./build-status.mjs";
+import { previewSessionDirectories, withPreviewSession } from "../preview-scope.mjs";
 
 function stamp(file) {
   try { const stat = statSync(file); return `${stat.mtimeMs}:${stat.ctimeMs}:${stat.size}`; }
@@ -160,23 +161,27 @@ export function createPreviewWatch(root, config, { log = process.stderr, buildTi
   }
 
   const status = () => ({ state, ...(stalled ? { stalled: true } : {}), ...(child?.pid ? { pid: child.pid } : {}), ...(ownerGuard?.pid ? { guardPid: ownerGuard.pid } : {}), ...(error ? { error } : {}) });
-  const buildStatus = () => inspectBuildStatus(root, config, command ? { session, file: reportFile, processState: status() } : {});
+  const resourceSession = () => command && config.previewManifest ? session : undefined;
+  const buildStatus = () => inspectBuildStatus(root, config, command ? { session, previewSession: resourceSession(), file: reportFile, processState: status() } : {});
+  function clearOutput() {
+    for (const directory of previewSessionDirectories(withPreviewSession({ root, config: { mcp: config } }, resourceSession()))) rmSync(directory, { recursive: true, force: true });
+  }
 
   async function stopChild() {
     rmSync(requestFile, { force: true });
     if (stopping) return stopping;
-    if (!child || childClosed) { if (command) state = "stopped"; rmSync(reportFile, { force: true }); return; }
+    if (!child || childClosed) { if (command) state = "stopped"; rmSync(reportFile, { force: true }); clearOutput(); return; }
     if (state === "stopped") return;
     state = "stopping";
     stopping = (async () => {
       kill("SIGTERM");
       clearTimeout(killTimer);
       const timer = setTimeout(() => kill("SIGKILL"), 1500);
-      try { await closed; } finally { clearTimeout(timer); rmSync(reportFile, { force: true }); }
+      try { await closed; } finally { clearTimeout(timer); rmSync(reportFile, { force: true }); clearOutput(); }
     })();
     return stopping;
   }
-  return { start, ensure, async stop() { disposed = true; await restarting; return stopChild(); }, kill: () => kill("SIGKILL"), status, buildStatus, setApps(apps) {
+  return { start, ensure, async stop() { disposed = true; await restarting; return stopChild(); }, kill: () => kill("SIGKILL"), status, resourceSession, buildStatus, setApps(apps) {
     for (const app of apps) {
       const file = path.resolve(root, app.file);
       if (!baselines.has(file)) baselines.set(file, stamp(file));
@@ -195,6 +200,7 @@ export function createReconfigurablePreviewWatch(root, config, options) {
     start() { if (!stopped && !replacing) current.start(); },
     async ensure(file, signal) { await pending; if (stopped) throw new Error("Preview watcher is stopped."); return current.ensure(file, signal); },
     status() { return replacing ? { state: "reconfiguring" } : current.status(); },
+    resourceSession() { return current.resourceSession(); },
     buildStatus() { return current.buildStatus(); },
     setApps(next) { apps = next; current.setApps(next); },
     kill() { current.kill(); },