@eduardorenani/atlasjs 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Eduardo Renani
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied. See the License for the specific language governing
+   permissions and limitations under the License.

package/README.md

@@ -0,0 +1,113 @@
+# @eduardorenani/atlasjs
+
+Mode-based agent orchestration on top of [XState v5](https://stately.ai/docs/xstate).
+
+> **Alpha.** The API is stable enough to build with, but minor 0.x bumps may still break shape. Pin exact versions.
+
+## Why
+
+Building an AI agent on a raw state machine forces every mode (greeting, answering, teaching, etc.) into ad-hoc actor/onDone/guard plumbing. `@eduardorenani/atlasjs` collapses that into three constructors and a four-outcome contract so the agent's structure stays in the modes — not in the wiring.
+
+- A **mode** is a unit of agentic work with one well-defined **goal**.
+- Every mode terminates with one of four **outcomes**: `achieved` / `retry` / `abandoned` / `error`.
+- **Exits are bound to outcomes** — routing is over the outcome plus its typed payload, never over arbitrary conditions.
+
+The type system rejects anything that does not fit: active+passive mixing in the same leaf mode, modes missing outcomes, cross-compound targets, `retry` with an arbitrary target.
+
+## Install
+
+```bash
+npm install @eduardorenani/atlasjs@alpha xstate
+```
+
+`xstate@^5` is a peer dependency — install it explicitly. Node 20+ required, ESM only.
+
+## 30-second tour
+
+A trivial agent with two modes: `listening` waits for a user message, `answering` calls an LLM and routes back to `listening`.
+
+```ts
+import { createActor } from "xstate";
+import { defineMode, defineAgent } from "@eduardorenani/atlasjs";
+
+type Ctx = { question: string; answer: string };
+type Ev = { type: "ASK"; question: string };
+
+// Passive mode — waits for an event. Inline callbacks aren't allowed in `on`;
+// transitions reference reusable actions declared on `defineAgent` below.
+const listening = defineMode<Ctx, Ev>({
+    on: {
+        ASK: {
+            target: "answering",
+            actions: "captureQuestion",
+        },
+    },
+});
+
+// Active mode — runs an async `behavior` and dispatches on its outcome.
+// All three outcome buckets (achieved / retry / abandoned) are required;
+// pass `[]` for retry when there's no retry policy.
+const answering = defineMode<Ctx, Ev, { answer: string }>({
+    input: ({ context }) => ({ question: context.question }),
+    behavior: async ({ input }) => {
+        const { question } = input as { question: string };
+        const answer = await callYourLLM(question);
+        return { outcome: "achieved", payload: { answer } };
+    },
+    routes: {
+        achieved: {
+            target: "listening",
+            assign: ({ payload }) => ({ answer: payload.answer }),
+        },
+        retry: [],
+        abandoned: { target: "listening" },
+    },
+});
+
+const machine = defineAgent<
+    Ctx,
+    Ev,
+    { listening: typeof listening; answering: typeof answering }
+>({
+    id: "qa",
+    initial: "listening",
+    context: { question: "", answer: "" },
+    events: {} as Ev,
+    actions: {
+        captureQuestion: ({ event }) => ({ question: event.question }),
+    },
+    modes: { listening, answering },
+});
+
+const actor = createActor(machine).start();
+actor.send({ type: "ASK", question: "What is a mode?" });
+```
+
+`behavior` returns `{ outcome, payload }`. The route on `achieved` is the **only** way out of a successful run — there is no untyped escape hatch.
+
+## The three constructors
+
+| Constructor          | Purpose                                                                   |
+| -------------------- | ------------------------------------------------------------------------- |
+| `defineMode`         | A leaf mode. Pass `{ input, behavior, routes }` for active, `{ on }` for passive. Mixing is a compile error. |
+| `defineCompoundMode` | A composite of nested modes. Routes to `END` to exit; the enclosing scope's `onDone` picks the destination. |
+| `defineAgent`        | The top-level entry. Compiles to an XState machine ready for `createActor`. |
+
+## Concepts in 60 seconds
+
+- **Active mode** — runs an async `behavior` that returns `ModeOutput<TPayload>`. Routing is declared upfront under `routes.{achieved,retry,abandoned}`. Optional `routes.error` catches rejections; if absent, errors re-throw above the actor (no silent swallow).
+- **Passive mode** — waits for events declared in `on`. Transitions reference named `actions` on `defineAgent`, never inline closures (keeps DD-004 churn out of state files).
+- **Compound mode** — groups child modes under an `initial` slot. Children exit the compound by routing to `END`; the parent's `onDone` decides where to go next. Compounds can declare lexically-scoped `context` (inherited keys + local resets on re-entry).
+- **Deps** — `defineAgent({ deps: { ... } })` exposes a frozen container of external resources (DB, logger, LLM client) to every `input` / `behavior` / `assign`. Defaults to `{}` when omitted.
+- **JSON-safe context** — `context` (root and compound-local) is checked against `JsonCompatible<T>` so snapshots round-trip through any storage layer.
+
+## Where to go next
+
+- **API reference** — the type signatures and JSDoc in [`packages/atlas/src/types.ts`](https://github.com/EduardoRenani/atlas/blob/main/packages/atlas/src/types.ts) are the source of truth.
+- **Worked example** — [`examples/zoe/`](https://github.com/EduardoRenani/atlas/tree/main/examples/zoe) is a CLI agent that classifies user intent and dispatches across greetings / improvising / socratic modes.
+- **Specs** — the API contract lives in [`docs/specs/004-xstate-agent-wrapper.md`](https://github.com/EduardoRenani/atlas/blob/main/docs/specs/004-xstate-agent-wrapper.md), [`005-agent-deps-and-stringifiable-context.md`](https://github.com/EduardoRenani/atlas/blob/main/docs/specs/005-agent-deps-and-stringifiable-context.md), and [`006-modes-not-states.md`](https://github.com/EduardoRenani/atlas/blob/main/docs/specs/006-modes-not-states.md).
+- **Design decisions** — [`docs/design-decisions.md`](https://github.com/EduardoRenani/atlas/blob/main/docs/design-decisions.md) records the "why" behind the four-outcome contract, goal-bound exits, and the modes-not-states vocabulary.
+
+## License
+
+Apache-2.0. See [`LICENSE`](https://github.com/EduardoRenani/atlas/blob/main/LICENSE).

package/dist/actorName.d.ts

@@ -0,0 +1,2 @@
+export declare function actorName(path: string): string;
+//# sourceMappingURL=actorName.d.ts.map

package/dist/actorName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actorName.d.ts","sourceRoot":"","sources":["../src/actorName.ts"],"names":[],"mappings":"AAWA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAY9C"}

package/dist/actorName.js

@@ -0,0 +1,24 @@
+// Derive the XState actor name for an active `Mode` (leaf) from its
+// root-relative path. Spec: docs/design-decisions.md DD-008 — actor names
+// are `<camelCase(path)>Node`. Encoding the convention as code (here) makes
+// DD-008 an invariant enforced by the compiler, not a hand-maintained rule.
+//
+// Examples:
+//   "listening"             → "listeningNode"
+//   "classifying"           → "classifyingNode"
+//   "socratic.evaluating"   → "socraticEvaluatingNode"
+//   "greetings.thinking"    → "greetingsThinkingNode"
+export function actorName(path) {
+    if (path === "") {
+        throw new Error("atlas/actorName: empty path");
+    }
+    const segments = path.split(".");
+    if (segments.some((s) => s === "")) {
+        throw new Error(`atlas/actorName: malformed path "${path}" (empty segment)`);
+    }
+    const camel = segments
+        .map((seg, i) => (i === 0 ? seg : seg.charAt(0).toUpperCase() + seg.slice(1)))
+        .join("");
+    return `${camel}Node`;
+}
+//# sourceMappingURL=actorName.js.map

package/dist/actorName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actorName.js","sourceRoot":"","sources":["../src/actorName.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,0EAA0E;AAC1E,4EAA4E;AAC5E,4EAA4E;AAC5E,EAAE;AACF,YAAY;AACZ,8CAA8C;AAC9C,gDAAgD;AAChD,uDAAuD;AACvD,sDAAsD;AAEtD,MAAM,UAAU,SAAS,CAAC,IAAY;IAClC,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;IACnD,CAAC;IACD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,oCAAoC,IAAI,mBAAmB,CAAC,CAAC;IACjF,CAAC;IACD,MAAM,KAAK,GAAG,QAAQ;SACjB,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;SAC7E,IAAI,CAAC,EAAE,CAAC,CAAC;IACd,OAAO,GAAG,KAAK,MAAM,CAAC;AAC1B,CAAC"}

package/dist/buildActions.d.ts

@@ -0,0 +1,11 @@
+import { assign } from "xstate";
+type UserActionCallback = (args: {
+    context: unknown;
+    event: {
+        type: string;
+    };
+    deps: Readonly<Record<string, unknown>>;
+}) => object;
+export declare function buildActions(actions: Readonly<Record<string, UserActionCallback>> | undefined, deps: Readonly<Record<string, unknown>>): Record<string, ReturnType<typeof assign>>;
+export {};
+//# sourceMappingURL=buildActions.d.ts.map

package/dist/buildActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildActions.d.ts","sourceRoot":"","sources":["../src/buildActions.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,KAAK,kBAAkB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACxB,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC3C,KAAK,MAAM,CAAC;AAEb,wBAAgB,YAAY,CACxB,OAAO,EACD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,GAC5C,SAAS,EACf,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC,CAO3C"}

package/dist/buildActions.js

@@ -0,0 +1,23 @@
+// Wrap `defineAgent.actions` callbacks so each lives in
+// `setup({ actions: { name: assign(...) } })`. Spec:
+// docs/specs/004-tasks.md Phase 5.5 + docs/specs/004-xstate-agent-wrapper.md
+// §"Actions: named in passive, inline in routes" + §Mapping.
+// Spec 005: the wrapper closes over the agent's frozen `deps` reference
+// and threads it into every named action's argument envelope.
+//
+// The user wrote a plain callback returning `Partial<TContext>`. The wrapper
+// is the only place that calls `xstate.assign(...)` for these — user code
+// never imports from `xstate`. The callback's return type is forwarded to
+// XState untouched (a runtime identity — the wrapper just adds the assign
+// envelope so XState applies the patch to the context store).
+import { assign } from "xstate";
+export function buildActions(actions, deps) {
+    if (actions === undefined)
+        return {};
+    const out = {};
+    for (const [name, callback] of Object.entries(actions)) {
+        out[name] = assign(({ context, event }) => callback({ context, event, deps }));
+    }
+    return out;
+}
+//# sourceMappingURL=buildActions.js.map

package/dist/buildActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildActions.js","sourceRoot":"","sources":["../src/buildActions.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,qDAAqD;AACrD,6EAA6E;AAC7E,6DAA6D;AAC7D,wEAAwE;AACxE,8DAA8D;AAC9D,EAAE;AACF,6EAA6E;AAC7E,0EAA0E;AAC1E,0EAA0E;AAC1E,0EAA0E;AAC1E,8DAA8D;AAE9D,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQhC,MAAM,UAAU,YAAY,CACxB,OAEe,EACf,IAAuC;IAEvC,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IACrC,MAAM,GAAG,GAA8C,EAAE,CAAC;IAC1D,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACrD,GAAG,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IACnF,CAAC;IACD,OAAO,GAAG,CAAC;AACf,CAAC"}

package/dist/buildActiveState.d.ts

@@ -0,0 +1,43 @@
+import { assign } from "xstate";
+import { type LiftContext } from "./contextLift.js";
+import type { ErrorRouteTarget, ModeOutput, RouteTarget } from "./types.js";
+import type { LeafSlot } from "./walk.js";
+export type LoweredGuard = (args: {
+    event: {
+        output: ModeOutput<unknown>;
+    };
+}) => boolean;
+export type LoweredOnDoneTransition = {
+    guard?: LoweredGuard;
+    target?: RouteTarget;
+    reenter?: boolean;
+    actions?: ReturnType<typeof assign>;
+};
+export type LoweredErrorGuard = (args: {
+    event: {
+        error: unknown;
+    };
+}) => boolean;
+export type LoweredReThrowAction = (args: {
+    event: {
+        error: unknown;
+    };
+}) => never;
+export type LoweredErrorAction = ReturnType<typeof assign> | LoweredReThrowAction;
+export type LoweredOnErrorTransition = {
+    guard?: LoweredErrorGuard;
+    target?: ErrorRouteTarget;
+    actions?: LoweredErrorAction;
+};
+export type LoweredInvokeState = {
+    invoke: {
+        src: string;
+        input: (args: {
+            context: unknown;
+        }) => unknown;
+        onDone: readonly LoweredOnDoneTransition[];
+        onError?: readonly LoweredOnErrorTransition[];
+    };
+};
+export declare function buildActiveState(slot: LeafSlot, lift: LiftContext | undefined, deps: Readonly<Record<string, unknown>>): LoweredInvokeState;
+//# sourceMappingURL=buildActiveState.d.ts.map

package/dist/buildActiveState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildActiveState.d.ts","sourceRoot":"","sources":["../src/buildActiveState.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,EAIH,KAAK,WAAW,EACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAER,gBAAgB,EAGhB,UAAU,EAGV,WAAW,EAEd,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAe1C,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE;IAC9B,KAAK,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;CAC1C,KAAK,OAAO,CAAC;AAEd,MAAM,MAAM,uBAAuB,GAAG;IAClC,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,MAAM,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE;IACnC,KAAK,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;CAC7B,KAAK,OAAO,CAAC;AAKd,MAAM,MAAM,oBAAoB,GAAG,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;CAC7B,KAAK,KAAK,CAAC;AAEZ,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,MAAM,CAAC,GAAG,oBAAoB,CAAC;AAElF,MAAM,MAAM,wBAAwB,GAAG;IACnC,KAAK,CAAC,EAAE,iBAAiB,CAAC;IAC1B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC7B,MAAM,EAAE;QACJ,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,CAAC,IAAI,EAAE;YAAE,OAAO,EAAE,OAAO,CAAA;SAAE,KAAK,OAAO,CAAC;QAC/C,MAAM,EAAE,SAAS,uBAAuB,EAAE,CAAC;QAC3C,OAAO,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;KACjD,CAAC;CACL,CAAC;AA0KF,wBAAgB,gBAAgB,CAC5B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,WAAW,GAAG,SAAS,EAC7B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,kBAAkB,CAmDpB"}

package/dist/buildActiveState.js

@@ -0,0 +1,194 @@
+// Lower an active `Mode` (leaf) slot to an XState `{ invoke: { src, input, onDone, onError? } }`
+// state. Spec: docs/specs/004-tasks.md Phase 5.6 + 5.7 + 5.9 +
+// docs/specs/004-xstate-agent-wrapper.md §Mapping.
+// Spec 005: every user callback envelope (input, behavior, routes.*.assign)
+// is extended with the agent's frozen `deps` reference, captured here in
+// each generated closure.
+//
+// Cardinality and order of `onDone[i]`:
+//   - one entry per `routes.achieved` route entry, in order
+//   - then one entry per `routes.retry` route entry, in order
+//     (zero if `retry: readonly []`)
+//   - then one entry per `routes.abandoned` route entry, in order
+//
+// Each `onDone[i]` carries:
+//   - `target`:
+//       achieved / abandoned → the entry's own `target` (END symbol stays;
+//       slice 5.11 rewrites it to `$end`)
+//       retry → the leaf's last-segment sibling name, with `reenter: true`
+//       so XState re-fires the invoke
+//   - `guard`: combines `event.output.outcome === "<key>"` with the user's
+//     optional `when(payload)` — the entry only fires for the matching
+//     outcome AND only when the user's payload-typed predicate agrees
+//   - `actions`: the user's optional `assign` callback wrapped in XState's
+//     `assign(...)`, with `event.output.payload` bridged into the `payload`
+//     argument the user typed against, and `deps` threaded from the
+//     closure that `buildActiveState` was called with
+//
+// `routes.error` → `invoke.onError[i]` with the same shape as onDone, except:
+//   - guard sees `event.error` instead of `event.output.{outcome,payload}`
+//   - target may be `RE_THROW` (a symbol); the actual re-throw action is
+//     emitted in slice 5.10 — slice 5.9 leaves RE_THROW as-is in `target`.
+// When `routes.error` is omitted, no `onError` field is emitted — XState's
+// default (rejection halts the actor) matches the spec's "wrapper re-throws"
+// guarantee.
+import { assign } from "xstate";
+import { actorName } from "./actorName.js";
+import { liftErrorAssign, liftExitAssign, liftInput, } from "./contextLift.js";
+import { RE_THROW } from "./types.js";
+// `Array.isArray` widens `readonly T[]` to `any[]` and does not subtract it
+// from a `T | readonly T[]` union. A typed predicate fixes the narrowing
+// without leaking `any`.
+function isReadonlyArray(value) {
+    return Array.isArray(value);
+}
+function normalizeExitEntries(entry) {
+    return isReadonlyArray(entry) ? entry : [entry];
+}
+function normalizeRetryEntries(entry) {
+    return isReadonlyArray(entry) ? entry : [entry];
+}
+function normalizeErrorEntries(entry) {
+    return isReadonlyArray(entry) ? entry : [entry];
+}
+function makeGuard(outcomeKey, userWhen) {
+    return ({ event }) => {
+        if (event.output.outcome !== outcomeKey)
+            return false;
+        if (userWhen === undefined)
+            return true;
+        return userWhen(event.output.payload);
+    };
+}
+// Bridge `entry.assign({ context, payload, deps })` to XState's
+// `assign(({ context, event }) => ...)`. The payload narrowing the user
+// typed against is preserved through `event.output.payload`. The `deps`
+// reference is captured from the closure that `buildActiveState` was
+// called with — every emitted callback sees the same frozen object by
+// identity.
+//
+// When a `lift` is in effect (the enclosing compound declared
+// `context: { inherit, local }`), delegate to `liftExitAssign` instead:
+// it presents the virtual `Pick<TParent, inherit[number]> & local` view to
+// the user's callback and splits the returned partial back to the right
+// destination (agent root vs. ancestor slot vs. own slot). `deps` is
+// forwarded verbatim through the lift wrapper.
+function wrapAssign(userAssign, lift, deps) {
+    if (lift !== undefined) {
+        return liftExitAssign(userAssign, lift, deps);
+    }
+    return assign(({ context, event }) => {
+        const output = event.output;
+        return userAssign({ context, payload: output.payload, deps });
+    });
+}
+function buildExitTransition(outcomeKey, entry, lift, deps) {
+    const transition = {
+        guard: makeGuard(outcomeKey, entry.when),
+        target: entry.target,
+    };
+    if (entry.assign !== undefined) {
+        transition.actions = wrapAssign(entry.assign, lift, deps);
+    }
+    return transition;
+}
+function buildRetryTransition(selfSegment, entry, lift, deps) {
+    const transition = {
+        guard: makeGuard("retry", entry.when),
+        target: selfSegment,
+        reenter: true,
+    };
+    if (entry.assign !== undefined) {
+        transition.actions = wrapAssign(entry.assign, lift, deps);
+    }
+    return transition;
+}
+function makeErrorGuard(userWhen) {
+    return ({ event }) => {
+        if (userWhen === undefined)
+            return true;
+        return userWhen(event.error);
+    };
+}
+function wrapErrorAssign(userAssign, lift, deps) {
+    if (lift !== undefined) {
+        return liftErrorAssign(userAssign, lift, deps);
+    }
+    return assign(({ context, event }) => {
+        const error = event.error;
+        return userAssign({ context, error, deps });
+    });
+}
+// Re-throw action emitted for `target: RE_THROW` entries. Throwing inside an
+// XState v5 action causes the invoking actor to surface the error, which
+// propagates above the leaf — matching the spec's RE_THROW semantics. The
+// transition itself carries no `target`; the re-throw IS the side effect.
+function makeReThrowAction() {
+    return ({ event }) => {
+        throw event.error;
+    };
+}
+function buildErrorTransition(entry, lift, deps) {
+    const guard = makeErrorGuard(entry.when);
+    if (entry.target === RE_THROW) {
+        // Spec line 833: `assign` on a RE_THROW entry is dropped at compile
+        // time. The dispatch walk treats RE_THROW as terminal — XState's
+        // first-match-wins ordering plus the thrown rejection naturally
+        // prevent any later entry from running.
+        return {
+            guard,
+            actions: makeReThrowAction(),
+        };
+    }
+    const transition = {
+        guard,
+        target: entry.target,
+    };
+    if (entry.assign !== undefined) {
+        transition.actions = wrapErrorAssign(entry.assign, lift, deps);
+    }
+    return transition;
+}
+export function buildActiveState(slot, lift, deps) {
+    const config = slot.config;
+    if (!("behavior" in config)) {
+        throw new Error(`atlas/buildActiveState: leaf at "${slot.path}" is passive — use buildPassiveState`);
+    }
+    const routes = config.routes;
+    const segments = slot.path.split(".");
+    const selfSegment = segments[segments.length - 1];
+    if (selfSegment === undefined || selfSegment === "") {
+        throw new Error(`atlas/buildActiveState: malformed leaf path "${slot.path}"`);
+    }
+    const onDone = [];
+    for (const entry of normalizeExitEntries(routes.achieved)) {
+        onDone.push(buildExitTransition("achieved", entry, lift, deps));
+    }
+    for (const entry of normalizeRetryEntries(routes.retry)) {
+        onDone.push(buildRetryTransition(selfSegment, entry, lift, deps));
+    }
+    for (const entry of normalizeExitEntries(routes.abandoned)) {
+        onDone.push(buildExitTransition("abandoned", entry, lift, deps));
+    }
+    // The user's `input` callback gains a `deps` parameter; wrap it so the
+    // XState-facing input fn matches the existing `({ context }) => unknown`
+    // shape while injecting `deps` from the closure.
+    const userInput = config.input;
+    const wrappedInput = lift !== undefined
+        ? liftInput(userInput, lift, deps)
+        : ({ context }) => userInput({ context, deps });
+    const invoke = {
+        src: actorName(slot.path),
+        input: wrappedInput,
+        onDone,
+    };
+    if (routes.error !== undefined) {
+        const onError = [];
+        for (const entry of normalizeErrorEntries(routes.error)) {
+            onError.push(buildErrorTransition(entry, lift, deps));
+        }
+        invoke.onError = onError;
+    }
+    return { invoke };
+}
+//# sourceMappingURL=buildActiveState.js.map

package/dist/buildActiveState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildActiveState.js","sourceRoot":"","sources":["../src/buildActiveState.ts"],"names":[],"mappings":"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"}