@jxsuite/studio 8.0.1 → 9.0.0

package/src/services/project-adoption.ts

@@ -11,9 +11,8 @@
 
 import { initProjectRepo } from "../files/files";
 import { getPlatform, hasPlatform } from "../platform";
-import { beginBatch, endBatch, isBatching } from "../tabs/transact";
+import { flushOpenBatches } from "../tabs/transact";
 import { workspace } from "../workspace/workspace";
-import type { Tab } from "../tabs/tab";
 
 let _adopter: ((root: string) => Promise<void>) | null = null;
 
@@ -52,8 +51,6 @@ export interface AdoptOutcome {
 
 /** The seams {@link adoptCreatedProject} runs through, so each caller keeps the one it already had. */
 export interface AdoptCreatedOptions {
-  /** The active tab, read AFTER adoption to re-anchor the agent loop's undo batch. */
-  getTab: () => Tab | null;
   /** The project-open flow. Defaults to this module's late-bound {@link adoptProject}. */
   adopt?: (root: string) => Promise<void>;
   /** Version-control init. Defaults to `files/files.ts`'s `initProjectRepo`. */
@@ -76,9 +73,8 @@ export interface AdoptCreatedOptions {
  * - **Verifying.** `openRecentProject` swallows its failures into a status message, so a resolved
  *   promise is not proof of adoption. The caller must be told which of the two happened.
  *
- * The batch dance is the third: the agent loop may hold an undo batch on the pre-adoption tab, and
- * adoption replaces every tab in the workspace. Flush it, adopt, re-open one on whatever tab
- * adoption left active.
+ * The third is the undo batch: the agent loop's lane may hold segments on pre-adoption tabs, and
+ * adoption replaces every tab in the workspace, so they are closed first (specs/ai.md §3.3).
  *
  * @param {string} root - Absolute root of the project that was just created.
  * @param {AdoptCreatedOptions} opts
@@ -86,7 +82,7 @@ export interface AdoptCreatedOptions {
  */
 export async function adoptCreatedProject(
   root: string,
-  { getTab, adopt = adoptProject, initRepo = initProjectRepo }: AdoptCreatedOptions,
+  { adopt = adoptProject, initRepo = initProjectRepo }: AdoptCreatedOptions = {},
 ): Promise<AdoptOutcome> {
   // Never fails the create: a project that was written stays written (initProjectRepo notifies).
   await initRepo(root);
@@ -117,19 +113,15 @@ export async function adoptCreatedProject(
     }
   }
 
-  const wasBatching = isBatching();
-  if (wasBatching) {
-    endBatch();
-  }
+  /* The tabs an open lane has segments on are about to be replaced: close each now, against the
+     document it was written into. The lane stays open, so the turn's next write opens a segment on
+     whatever document it writes in the adopted project. */
+  flushOpenBatches();
   let adoptionError: string | null = null;
   try {
     await adopt(root);
   } catch (error) {
     adoptionError = error instanceof Error ? error.message : String(error);
   }
-  if (wasBatching) {
-    beginBatch(getTab());
-  }
-
   return { adopted: workspace.projectRoot === root, error: adoptionError, openedElsewhere };
 }

package/src/services/tool-executor.ts

@@ -9,17 +9,19 @@
  *   happen (`services/harness/chat-reducer.ts`), and each round's request is projected from it, as
  *   it always was, so the provider sees the conversation the panel shows, with whatever the send
  *   path trimmed or sealed before the turn began.
- * - **A batch belongs to the tab it edits** (§3.3). The undo batch opens on the active tab and is
- *   re-anchored after every call whose tools moved to another document, so a turn that edits two
- *   documents gives each its own history step and collab publish.
+ * - **The batch belongs to the assistant** (§3.3). The turn opens a batch lane owned by its actor,
+ *   and every write the turn's tools make joins it, one segment per document written: each document
+ *   gets one history step and one collab publish, whichever tab is active, and a person's edit
+ *   during the turn closes the segment on that document rather than being folded into it.
  * - **The ledger is filed under the last message the turn drew** (§3.2), in this module's `finally`,
  *   so the transcript draws the turn's changed-files summary under it.
  *
  * @license MIT
  */
 
+import type { InteractionStore } from "./harness/interaction-store";
 import type { createChatState } from "@jxsuite/ai/chat-state";
-import { DEFAULT_TURN_POLICY, runTurn } from "@jxsuite/ai/harness";
+import { DEFAULT_TURN_POLICY, assistantActorId, runTurn } from "@jxsuite/ai/harness";
 import type { TurnInput, TurnRun } from "@jxsuite/ai/harness";
 import { toChatMessages, toOpenAITools } from "@jxsuite/ai/messages";
 import type { StreamingClient } from "@jxsuite/ai/streaming-client";
@@ -27,7 +29,7 @@ import { createSessionFacts } from "@jxsuite/ai/tools";
 import type { SessionFacts, ToolRegistry } from "@jxsuite/ai/tools";
 
 import type { Tab } from "../tabs/tab";
-import { batchTab, beginBatch, endBatch } from "../tabs/transact";
+import { openBatchLane } from "../tabs/transact";
 import { estimatePromptTokens } from "./context-manager";
 import { fileTurn, openTurnLedger, turnAnchor } from "./ai-writes";
 import { applyHarnessEvent } from "./harness/chat-reducer";
@@ -48,6 +50,8 @@ interface RunAgentLoopOptions {
   getTab?: () => Tab | null;
   /** The conversation's facts, which every call's context carries; a fresh set when omitted. */
   session?: SessionFacts;
+  /** Where a call that needs the author waits on them. Without one, such a call is refused. */
+  interactions?: InteractionStore;
 }
 
 /**
@@ -62,26 +66,23 @@ export async function runAgentLoop({
   signal,
   getTab,
   session = createSessionFacts(),
+  interactions,
 }: RunAgentLoopOptions): Promise<void> {
   /* The ledger is filed under the turn's last DRAWN assistant message (see services/ai-writes), so
      the scan starts at the message this turn answers. */
   const turnUserId = chatState.messages.findLast((m) => m.role === "user")?.id;
   const ledger = openTurnLedger(`turn:${chatState.messages.length}`);
 
-  // Batch all tool-call mutations into a single undo step, anchored on the tab being edited.
-  if (getTab) {
-    beginBatch(getTab());
-  }
-  const reanchorBatch = () => {
-    if (!getTab) {
-      return;
-    }
-    const current = getTab();
-    if (current !== batchTab()) {
-      endBatch();
-      beginBatch(current);
-    }
-  };
+  /* One undo step per document the turn writes. A loop with no `getTab` has no document of its own
+     (the evals), so it gets no lane and each tool is its own entry. The owner's id is the one each
+     call's context will carry, so a tool's write joins the lane by naming `ctx.actor`. */
+  const lane = getTab
+    ? openBatchLane({
+        id: assistantActorId(session.sessionId, ledger.turnId),
+        kind: "assistant",
+        turnId: ledger.turnId,
+      })
+    : null;
 
   /* The placeholder `sendMessage` pushed is round one's message, so the turn answers into it; the
      conversation the turn continues is everything before it. */
@@ -124,7 +125,6 @@ export async function runAgentLoop({
           superseded = true;
           run?.cancel("superseded");
         },
-        reanchor: reanchorBatch,
       }),
       session,
       ledger,
@@ -137,13 +137,16 @@ export async function runAgentLoop({
     if (signal) {
       input.signal = signal;
     }
+    if (interactions) {
+      input.interactions = interactions.strategy;
+    }
     if (placeholder) {
       input.firstMessageId = placeholder.id;
     }
     run = runTurn(input);
     await run.outcome;
   } finally {
-    endBatch();
-    fileTurn(turnAnchor(chatState.messages, turnUserId) ?? "", ledger.writes);
+    const batches = lane?.close() ?? [];
+    fileTurn(turnAnchor(chatState.messages, turnUserId) ?? "", ledger.writes, batches);
   }
 }

package/src/state.ts

@@ -154,19 +154,9 @@ export function pathsEqual(a: JxPath | null, b: JxPath | null) {
   return a.every((v, i) => v === b[i]);
 }
 
-/**
- * Returns true if `path` is an ancestor of (or equal to) `descendant`.
- *
- * @param {JxPath} path
- * @param {JxPath} descendant
- * @returns {boolean}
- */
-export function isAncestor(path: JxPath, descendant: JxPath) {
-  if (path.length > descendant.length) {
-    return false;
-  }
-  return path.every((v, i) => v === descendant[i]);
-}
+/* Lives beside the doc-op vocabulary (`@jxsuite/schema/doc-ops`), with the other structural-path
+   helpers; re-exported for the many callers that import it from here. */
+export { isAncestor } from "@jxsuite/schema/doc-ops";
 
 // ─── Tree flattening (for layer panel) ────────────────────────────────────────
 

package/src/style/stylebook-specimens.ts

@@ -5,14 +5,17 @@
  * component is rarely drawable that way: the museum starter's `<mu-exhibition-card>` formats a
  * `date` that defaults to `""`, so its card stayed empty and the canvas logged "was not rendered:
  * RangeError: Invalid time value" for it on every paint (`spec.md` §16.4). The Site panel's
- * previews already know where a component's sample props live (`browse/component-examples.ts`), so
- * a card asks the same three sources, in the same order, and draws:
+ * previews already know where a component's sample props live (`browse/component-examples.ts`: the
+ * definition's own `examples`), so a card asks the same source and draws:
  *
  * - `props`: an instance given its sample props, when the definition renders with them;
- * - `row`: the first row of a list that draws it, when it is only ever used as a list row;
- * - `bare`: the bare instance, when it renders with its defaults and nothing better was found;
- * - `none`: no live instance at all (the catalogue's placeholder box), when it renders with none of
- *   the above, because an instance that throws draws nothing and reports an error nobody can fix.
+ * - `bare`: the bare instance, when it renders with its defaults and has no sample props it renders
+ *   with;
+ * - `none`: no live instance at all (the catalogue's placeholder box), when it renders with neither,
+ *   because an instance that throws draws nothing and reports an error nobody can fix.
+ *
+ * Nothing here reads the rest of the project, so a catalogue of N components costs N definition
+ * reads and no usage queries.
  *
  * Answers are cached per component registry: the registry is replaced whenever the project's
  * components are re-read, so a changed definition is asked again.
@@ -20,17 +23,14 @@
  * @docs studio/design/stylebook
  */
 
-import { componentExampleProps, componentSampleRow } from "../browse/component-examples";
-import type { SampleRow } from "../browse/component-examples";
+import { componentExampleProps } from "../browse/component-examples";
 import { readDefinition, rendersWith } from "../browse/library-preview";
-import { defineComponent } from "../panels/component-preview";
 import type { ComponentEntry } from "../files/components";
 import type { JsonValue } from "@jxsuite/schema/types";
 
 /** How one component card is drawn; see the module comment. */
 export type StylebookSpecimen =
   | { kind: "props"; props: Record<string, JsonValue> }
-  | { kind: "row"; sample: SampleRow }
   | { kind: "bare" }
   | { kind: "none" };
 
@@ -49,14 +49,10 @@ export async function componentSpecimen(component: ComponentEntry): Promise<Styl
   if (!definition) {
     return { kind: "bare" };
   }
-  const props = await componentExampleProps(definition, path);
+  const props = componentExampleProps(definition);
   if (props.size > 0 && (await rendersWith(definition, path, props))) {
     return { kind: "props", props: Object.fromEntries(props) };
   }
-  const sample = await componentSampleRow(definition, path);
-  if (sample && (await defineComponent(component))) {
-    return { kind: "row", sample };
-  }
   return (await rendersWith(definition, path, new Map())) ? { kind: "bare" } : { kind: "none" };
 }
 

package/src/surfaces/files-panel.json

@@ -136,6 +136,18 @@
             }
           ]
         },
+        "address": {
+          "tagName": "div",
+          "attributes": {
+            "part": "empty"
+          },
+          "children": [
+            {
+              "tagName": "p",
+              "textContent": "Add ?project= and a project folder's absolute path to this page's address to open it."
+            }
+          ]
+        },
         "welcome": {
           "tagName": "div",
           "attributes": {

package/src/surfaces/files-panel.ts

@@ -81,8 +81,11 @@ export interface FileRowView {
 
 /** Everything the document draws, as one value. */
 export interface FilesPanelValues {
-  /** Which of three things the panel is: no project, a monorepo root, or a tree. */
-  view: "none" | "welcome" | "tree";
+  /**
+   * Which of four things the panel is: no project, a monorepo root on a host that can open a
+   * project, the same root on one that opens from the address (`?project=`), or a tree.
+   */
+  view: "none" | "welcome" | "address" | "tree";
   headerState: "hidden" | "shown";
   projectName: string;
   query: string;