@typeonce/effect-machine-devtools 0.24.0 → 0.26.0

package/src/internal/machineWalkthrough.ts

@@ -0,0 +1,355 @@
+import * as Result from "effect/Result"
+import type * as MachineDocument from "../MachineDocument.js"
+import type * as MachineWalkthrough from "../MachineWalkthrough.js"
+
+/** @internal */
+export const SessionTypeId = "@typeonce/effect-machine-devtools/MachineWalkthrough/Session" as const
+
+interface HistoryRecord {
+  readonly mode: "shallow" | "deep"
+  readonly paths: ReadonlyArray<string>
+}
+
+interface InternalSnapshot {
+  readonly activePaths: ReadonlyArray<string>
+  readonly history: ReadonlyMap<string, HistoryRecord>
+}
+
+interface InternalFrame {
+  readonly public: MachineWalkthrough.Frame
+  readonly snapshot: InternalSnapshot
+}
+
+interface SessionImpl extends MachineWalkthrough.Session {
+  readonly document: MachineDocument.MachineDocument
+  readonly cursor: number
+  readonly frames: ReadonlyArray<InternalFrame>
+}
+
+interface Model {
+  readonly states: ReadonlyMap<string, MachineDocument.State>
+  readonly order: ReadonlyMap<string, number>
+}
+
+interface PublicApi {
+  readonly ChoiceNotFound: typeof MachineWalkthrough.ChoiceNotFound
+  readonly ChoiceUnavailable: typeof MachineWalkthrough.ChoiceUnavailable
+  readonly StepNotFound: typeof MachineWalkthrough.StepNotFound
+}
+
+const makeModel = (document: MachineDocument.MachineDocument): Model => ({
+  states: new Map(document.states.map((state) => [state.path, state])),
+  order: new Map(document.states.map((state) => [state.path, state.order]))
+})
+
+const ordered = (model: Model, paths: Iterable<string>): ReadonlyArray<string> =>
+  [...new Set(paths)].sort((left, right) => (model.order.get(left) ?? 0) - (model.order.get(right) ?? 0))
+
+const ancestors = (model: Model, path: string): ReadonlyArray<string> => {
+  const result: Array<string> = []
+  let current = model.states.get(path)
+  while (current !== undefined) {
+    result.unshift(current.path)
+    current = current.parent === null ? undefined : model.states.get(current.parent)
+  }
+  return result
+}
+
+const isDescendant = (model: Model, path: string, ancestor: string): boolean =>
+  path !== ancestor && ancestors(model, path).includes(ancestor)
+
+const leastCommonAncestor = (model: Model, left: string, right: string): string | null => {
+  const leftAncestors = ancestors(model, left)
+  const rightAncestors = ancestors(model, right)
+  let result: string | null = null
+  const length = Math.min(leftAncestors.length, rightAncestors.length)
+  for (let index = 0; index < length; index++) {
+    if (leftAncestors[index] !== rightAncestors[index]) break
+    result = leftAncestors[index] ?? null
+  }
+  return result
+}
+
+const add = (active: Set<string>, entered: Set<string>, path: string): void => {
+  if (!active.has(path)) entered.add(path)
+  active.add(path)
+}
+
+const enter = (
+  model: Model,
+  path: string,
+  active: Set<string>,
+  entered: Set<string>,
+  history: ReadonlyMap<string, HistoryRecord>
+): void => {
+  const state = model.states.get(path)
+  if (state === undefined) return
+  if (state.type === "history") {
+    const record = history.get(path)
+    if (record === undefined) {
+      add(active, entered, path)
+      return
+    }
+    if (record.mode === "deep") {
+      record.paths.forEach((recorded) => add(active, entered, recorded))
+    } else {
+      record.paths.forEach((recorded) => enter(model, recorded, active, entered, history))
+    }
+    return
+  }
+  add(active, entered, path)
+  if (state.type === "parallel") {
+    state.children.forEach((child) => enter(model, child, active, entered, history))
+  } else if (state.type === "compound" && state.initial !== null) {
+    enter(model, state.initial, active, entered, history)
+  }
+}
+
+const completeParallelRegions = (
+  model: Model,
+  active: Set<string>,
+  entered: Set<string>,
+  history: ReadonlyMap<string, HistoryRecord>
+): void => {
+  for (const state of model.states.values()) {
+    if (state.type !== "parallel" || !active.has(state.path)) continue
+    state.children.forEach((child) => {
+      if (!active.has(child)) enter(model, child, active, entered, history)
+    })
+  }
+}
+
+const snapshot = (
+  model: Model,
+  activePaths: Iterable<string>,
+  history: ReadonlyMap<string, HistoryRecord>
+): InternalSnapshot => ({
+  activePaths: ordered(model, activePaths),
+  history: new Map(history)
+})
+
+const publicSnapshot = (value: InternalSnapshot): MachineWalkthrough.Snapshot => ({
+  activePaths: value.activePaths
+})
+
+const makeSession = (
+  document: MachineDocument.MachineDocument,
+  cursor: number,
+  frames: ReadonlyArray<InternalFrame>
+): MachineWalkthrough.Session =>
+  ({
+    [SessionTypeId]: SessionTypeId,
+    document,
+    cursor,
+    frames
+  }) as SessionImpl
+
+const session = (self: MachineWalkthrough.Session): SessionImpl => self as SessionImpl
+
+const initialSnapshot = (document: MachineDocument.MachineDocument, model: Model): InternalSnapshot => {
+  if (document.snapshot !== null) return snapshot(model, document.snapshot.activePaths, new Map())
+  const active = new Set<string>()
+  const entered = new Set<string>()
+  const targetAncestors = ancestors(model, document.initial.target)
+  targetAncestors.slice(0, -1).forEach((path) => add(active, entered, path))
+  enter(model, document.initial.target, active, entered, new Map())
+  return snapshot(model, active, new Map())
+}
+
+/** @internal */
+export const start = (document: MachineDocument.MachineDocument): MachineWalkthrough.Session => {
+  const model = makeModel(document)
+  const after = initialSnapshot(document, model)
+  const frame: MachineWalkthrough.Frame = {
+    step: 0,
+    choice: null,
+    before: { activePaths: [] },
+    after: publicSnapshot(after),
+    exitPaths: [],
+    entryPaths: after.activePaths,
+    changed: after.activePaths.length > 0
+  }
+  return makeSession(document, 0, [{ public: frame, snapshot: after }])
+}
+
+/** @internal */
+export const current = (self: MachineWalkthrough.Session): MachineWalkthrough.Frame => {
+  const value = session(self)
+  return value.frames[value.cursor]!.public
+}
+
+/** @internal */
+export const timeline = (self: MachineWalkthrough.Session): ReadonlyArray<MachineWalkthrough.Frame> =>
+  session(self).frames.map((frame) => frame.public)
+
+/** @internal */
+export const cursor = (self: MachineWalkthrough.Session): number => session(self).cursor
+
+const decisions = (
+  transition: MachineDocument.Transition,
+  branch: MachineDocument.Branch
+): ReadonlyArray<MachineWalkthrough.Decision> => {
+  const values = new Set<MachineWalkthrough.Decision>()
+  if (branch.type === "branch") values.add("conditional-branch")
+  if (transition.acceptance === "declinable") values.add("declinable-transition")
+  if (transition.trigger.type === "invoke") values.add("invoke-outcome")
+  else if (transition.trigger.type !== "event") values.add("automatic-trigger")
+  return [...values]
+}
+
+const unavailableReason = (
+  branch: MachineDocument.Branch,
+  history: ReadonlyMap<string, HistoryRecord>
+): MachineWalkthrough.UnavailableReason | null => {
+  if (branch.selection.kind === "history" && (branch.target === null || !history.has(branch.target))) {
+    return "history-unavailable"
+  }
+  if (
+    branch.target === null &&
+    branch.selection.kind !== "none" &&
+    branch.selection.kind !== "update"
+  ) return "runtime-target"
+  return null
+}
+
+/** @internal */
+export const choices = (self: MachineWalkthrough.Session): ReadonlyArray<MachineWalkthrough.Choice> => {
+  const value = session(self)
+  const frame = value.frames[value.cursor]!
+  const active = new Set(frame.snapshot.activePaths)
+  const eventInputs = new Map(value.document.inputs.events.map(({ event, schema }) => [event, schema]))
+  return value.document.transitions.flatMap((transition): ReadonlyArray<MachineWalkthrough.Choice> => {
+    if (!active.has(transition.source)) return []
+    return transition.branches.map((branch, branchIndex) => ({
+      id: branch.id,
+      transitionId: transition.id,
+      branchId: branch.id,
+      branchIndex,
+      branchKey: branch.type === "branch" ? branch.key : null,
+      title: branch.type === "branch" ? branch.title : null,
+      source: transition.source,
+      trigger: transition.trigger,
+      target: branch.target,
+      selection: branch.selection,
+      updates: branch.updates,
+      decisions: decisions(transition, branch),
+      unavailableReason: unavailableReason(branch, frame.snapshot.history),
+      input: transition.trigger.type === "event" ? eventInputs.get(transition.trigger.event) ?? null : null
+    }))
+  })
+}
+
+const recordHistory = (
+  document: MachineDocument.MachineDocument,
+  model: Model,
+  before: ReadonlySet<string>,
+  exited: ReadonlySet<string>,
+  history: Map<string, HistoryRecord>
+): void => {
+  for (const state of document.states) {
+    if (state.type !== "history" || state.parent === null || !exited.has(state.parent)) continue
+    const paths = state.history === "deep"
+      ? [...before].filter((path) => {
+        const node = model.states.get(path)
+        return isDescendant(model, path, state.parent!) && node?.type !== "history" && node?.type !== "choice"
+      })
+      : [...before].filter((path) => model.states.get(path)?.parent === state.parent)
+    if (paths.length > 0) {
+      history.set(state.path, {
+        mode: state.history === "deep" ? "deep" : "shallow",
+        paths: ordered(model, paths)
+      })
+    }
+  }
+}
+
+const advance = (
+  value: SessionImpl,
+  choice: MachineWalkthrough.Choice
+): {
+  readonly snapshot: InternalSnapshot
+  readonly exited: ReadonlyArray<string>
+  readonly entered: ReadonlyArray<string>
+} => {
+  const frame = value.frames[value.cursor]!
+  const model = makeModel(value.document)
+  if (choice.target === null) {
+    return { snapshot: frame.snapshot, exited: [], entered: [] }
+  }
+  const transition = value.document.transitions.find(({ id }) => id === choice.transitionId)!
+  const naturalBoundary = leastCommonAncestor(model, transition.source, choice.target)
+  const sourceParent = model.states.get(transition.source)?.parent ?? null
+  const boundary = transition.reenter
+    ? sourceParent === null || naturalBoundary === null
+      ? null
+      : ancestors(model, naturalBoundary).length <= ancestors(model, sourceParent).length
+      ? naturalBoundary
+      : sourceParent
+    : naturalBoundary
+  const before = new Set(frame.snapshot.activePaths)
+  const active = new Set(frame.snapshot.activePaths)
+  const exited = new Set(
+    frame.snapshot.activePaths.filter((path) => boundary === null || isDescendant(model, path, boundary))
+  )
+  const history = new Map(frame.snapshot.history)
+  recordHistory(value.document, model, before, exited, history)
+  exited.forEach((path) => active.delete(path))
+
+  const entered = new Set<string>()
+  const targetAncestors = ancestors(model, choice.target)
+  targetAncestors.slice(0, -1).forEach((path) => {
+    if (boundary === null || path === boundary || isDescendant(model, path, boundary)) add(active, entered, path)
+  })
+  enter(model, choice.target, active, entered, history)
+  completeParallelRegions(model, active, entered, history)
+  return {
+    snapshot: snapshot(model, active, history),
+    exited: ordered(model, exited),
+    entered: ordered(model, entered)
+  }
+}
+
+/** @internal */
+export const take = (api: PublicApi) =>
+(
+  self: MachineWalkthrough.Session,
+  choiceId: string
+): Result.Result<
+  MachineWalkthrough.Session,
+  MachineWalkthrough.ChoiceNotFound | MachineWalkthrough.ChoiceUnavailable
+> => {
+  const value = session(self)
+  const choice = choices(self).find(({ id }) => id === choiceId)
+  if (choice === undefined) return Result.fail(new api.ChoiceNotFound({ choiceId }))
+  if (choice.unavailableReason !== null) {
+    return Result.fail(new api.ChoiceUnavailable({ choiceId, reason: choice.unavailableReason }))
+  }
+  const beforeFrame = value.frames[value.cursor]!
+  const next = advance(value, choice)
+  const before = publicSnapshot(beforeFrame.snapshot)
+  const after = publicSnapshot(next.snapshot)
+  const frame: MachineWalkthrough.Frame = {
+    step: value.cursor + 1,
+    choice,
+    before,
+    after,
+    exitPaths: next.exited,
+    entryPaths: next.entered,
+    changed: next.exited.length > 0 || next.entered.length > 0
+  }
+  const frames = [...value.frames.slice(0, value.cursor + 1), { public: frame, snapshot: next.snapshot }]
+  return Result.succeed(makeSession(value.document, frames.length - 1, frames))
+}
+
+/** @internal */
+export const seek = (api: PublicApi) =>
+(
+  self: MachineWalkthrough.Session,
+  step: number
+): Result.Result<MachineWalkthrough.Session, MachineWalkthrough.StepNotFound> => {
+  const value = session(self)
+  if (!Number.isInteger(step) || step < 0 || step >= value.frames.length) {
+    return Result.fail(new api.StepNotFound({ step }))
+  }
+  return Result.succeed(makeSession(value.document, step, value.frames))
+}

package/src/internal/projectInspector.ts

@@ -39,14 +39,8 @@ interface EvaluationResponse {
   readonly results: ReadonlyArray<unknown>
 }
 
-interface SimulationWorkerRequest {
-  readonly _tag: "Simulate"
-  readonly root: string
-  readonly request: DevToolsProtocol.SimulationRequest
-}
-
-type WorkerRequest = EvaluationRequest | SimulationWorkerRequest
-type WorkerResponse = EvaluationResponse | DevToolsProtocol.SimulationResult
+type WorkerRequest = EvaluationRequest
+type WorkerResponse = EvaluationResponse
 
 const scriptKind = (file: string): ts.ScriptKind => {
   if (file.endsWith(".tsx")) return ts.ScriptKind.TSX
@@ -229,27 +223,6 @@ const evaluate = (
   )
 }
 
-const simulate = (
-  api: PublicApi,
-  request: DevToolsProtocol.SimulationRequest,
-  options: Pick<ProjectInspector.InspectOptions, "root">
-): Effect.Effect<DevToolsProtocol.SimulationResult, ProjectInspector.EvaluationError> =>
-  runWorker({ _tag: "Simulate", root: options.root, request }).pipe(
-    Effect.timeout("10 seconds"),
-    Effect.flatMap((response) => {
-      if (response._tag === "InspectedMachines") {
-        return Effect.fail(new Error("The isolated planner returned an inspection response"))
-      }
-      return Schema.decodeUnknownEffect(DevToolsProtocol.SimulationResult)(response)
-    }),
-    Effect.mapError((cause) =>
-      new api.EvaluationError({
-        message: "The isolated machine planner failed",
-        cause
-      })
-    )
-  )
-
 const make = (api: PublicApi) =>
   Effect.gen(function*() {
     const discover = yield* makeDiscovery(api)
@@ -258,8 +231,7 @@ const make = (api: PublicApi) =>
     return api.ProjectInspector.of({
       discover,
       evaluate: (candidates, options) => evaluate(api, candidates, options),
-      inspect,
-      simulate: (request, options) => simulate(api, request, options)
+      inspect
     })
   })
 

package/dist/MachineSimulator.d.ts

@@ -1,169 +0,0 @@
-/**
- * Side-effect-free, best-effort simulation over a machine document.
- *
- * @since 0.23.0
- */
-import * as Schema from "effect/Schema";
-import type * as MachineDocument from "./MachineDocument.js";
-/**
- * Serializable state of a simulation session.
- *
- * @category schemas
- * @since 0.23.0
- */
-export declare const Snapshot: Schema.Struct<{
-    readonly step: Schema.Natural;
-    readonly activePaths: Schema.$Array<Schema.String>;
-    readonly candidateEvents: Schema.$Array<Schema.String>;
-}>;
-/**
- * @category models
- * @since 0.23.0
- */
-export type Snapshot = Schema.Schema.Type<typeof Snapshot>;
-/**
- * Opaque simulation state paired with its source document.
- *
- * @category models
- * @since 0.23.0
- */
-export interface Session {
-    readonly document: MachineDocument.MachineDocument;
-    readonly snapshot: Snapshot;
-}
-/**
- * Runtime behavior deliberately skipped by a best-effort step.
- *
- * @category schemas
- * @since 0.23.0
- */
-export declare const Note: Schema.Literals<readonly ["runtime-effects-skipped", "state-updates-skipped", "reentry-lifecycles-skipped", "automatic-transitions-skipped"]>;
-/**
- * @category models
- * @since 0.23.0
- */
-export type Note = Schema.Schema.Type<typeof Note>;
-/**
- * A topologically deterministic step.
- *
- * @category schemas
- * @since 0.23.0
- */
-export declare const Applied: Schema.Struct<{
-    readonly _tag: Schema.tag<"Applied">;
-    readonly notes: Schema.$Array<Schema.Literals<readonly ["runtime-effects-skipped", "state-updates-skipped", "reentry-lifecycles-skipped", "automatic-transitions-skipped"]>>;
-    readonly event: Schema.String;
-    readonly transitionIds: Schema.$Array<Schema.String>;
-    readonly session: Schema.Struct<{
-        readonly step: Schema.Natural;
-        readonly activePaths: Schema.$Array<Schema.String>;
-        readonly candidateEvents: Schema.$Array<Schema.String>;
-    }>;
-}>;
-/**
- * @category models
- * @since 0.23.0
- */
-export type Applied = Schema.Schema.Type<typeof Applied>;
-/**
- * An event with no registration in the current active configuration.
- *
- * @category schemas
- * @since 0.23.0
- */
-export declare const Blocked: Schema.Struct<{
-    readonly _tag: Schema.tag<"Blocked">;
-    readonly reason: Schema.Literal<"event-not-enabled">;
-    readonly event: Schema.String;
-    readonly transitionIds: Schema.$Array<Schema.String>;
-    readonly session: Schema.Struct<{
-        readonly step: Schema.Natural;
-        readonly activePaths: Schema.$Array<Schema.String>;
-        readonly candidateEvents: Schema.$Array<Schema.String>;
-    }>;
-}>;
-/**
- * @category models
- * @since 0.23.0
- */
-export type Blocked = Schema.Schema.Type<typeof Blocked>;
-/**
- * A step whose topology depends on runtime behavior the document cannot safely
- * evaluate.
- *
- * @category schemas
- * @since 0.23.0
- */
-export declare const Indeterminate: Schema.Struct<{
-    readonly _tag: Schema.tag<"Indeterminate">;
-    readonly reason: Schema.Literals<readonly ["multiple-transitions", "declinable-transition", "conditional-branches", "history-target", "choice-target", "missing-target"]>;
-    readonly event: Schema.String;
-    readonly transitionIds: Schema.$Array<Schema.String>;
-    readonly session: Schema.Struct<{
-        readonly step: Schema.Natural;
-        readonly activePaths: Schema.$Array<Schema.String>;
-        readonly candidateEvents: Schema.$Array<Schema.String>;
-    }>;
-}>;
-/**
- * @category models
- * @since 0.23.0
- */
-export type Indeterminate = Schema.Schema.Type<typeof Indeterminate>;
-/**
- * @category schemas
- * @since 0.23.0
- */
-export declare const StepResult: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.tag<"Applied">;
-    readonly notes: Schema.$Array<Schema.Literals<readonly ["runtime-effects-skipped", "state-updates-skipped", "reentry-lifecycles-skipped", "automatic-transitions-skipped"]>>;
-    readonly event: Schema.String;
-    readonly transitionIds: Schema.$Array<Schema.String>;
-    readonly session: Schema.Struct<{
-        readonly step: Schema.Natural;
-        readonly activePaths: Schema.$Array<Schema.String>;
-        readonly candidateEvents: Schema.$Array<Schema.String>;
-    }>;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"Blocked">;
-    readonly reason: Schema.Literal<"event-not-enabled">;
-    readonly event: Schema.String;
-    readonly transitionIds: Schema.$Array<Schema.String>;
-    readonly session: Schema.Struct<{
-        readonly step: Schema.Natural;
-        readonly activePaths: Schema.$Array<Schema.String>;
-        readonly candidateEvents: Schema.$Array<Schema.String>;
-    }>;
-}>, Schema.Struct<{
-    readonly _tag: Schema.tag<"Indeterminate">;
-    readonly reason: Schema.Literals<readonly ["multiple-transitions", "declinable-transition", "conditional-branches", "history-target", "choice-target", "missing-target"]>;
-    readonly event: Schema.String;
-    readonly transitionIds: Schema.$Array<Schema.String>;
-    readonly session: Schema.Struct<{
-        readonly step: Schema.Natural;
-        readonly activePaths: Schema.$Array<Schema.String>;
-        readonly candidateEvents: Schema.$Array<Schema.String>;
-    }>;
-}>]>;
-/**
- * @category models
- * @since 0.23.0
- */
-export type StepResult = Schema.Schema.Type<typeof StepResult>;
-/**
- * Starts from the captured snapshot when present, otherwise from the static
- * initial topology.
- *
- * @category constructors
- * @since 0.23.0
- */
-export declare const start: (document: MachineDocument.MachineDocument) => Session;
-/**
- * Sends an event without running user code. `Applied` means the active topology
- * is statically known; its notes list runtime behavior that was skipped.
- *
- * @category combinators
- * @since 0.23.0
- */
-export declare const send: (session: Session, event: string) => StepResult;
-//# sourceMappingURL=MachineSimulator.d.ts.map

package/dist/MachineSimulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MachineSimulator.d.ts","sourceRoot":"","sources":["../src/MachineSimulator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;EAInB,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC,eAAe,CAAA;IAClD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAC5B;AAED;;;;;GAKG;AACH,eAAO,MAAM,IAAI,+IAKf,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAA;AAQlD;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;EAIlB,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;EAIlB,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,OAAO,CAAC,CAAA;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;EAWxB,CAAA;AAEF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA;AAEpE;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAkD,CAAA;AAEzE;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAA;AAE9D;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC,eAAe,KAAK,OAAwB,CAAA;AAE3F;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,UAA0B,CAAA"}

package/dist/MachineSimulator.js

@@ -1,98 +0,0 @@
-/**
- * Side-effect-free, best-effort simulation over a machine document.
- *
- * @since 0.23.0
- */
-import * as Schema from "effect/Schema";
-import * as internal from "./internal/machineSimulator.js";
-/**
- * Serializable state of a simulation session.
- *
- * @category schemas
- * @since 0.23.0
- */
-export const Snapshot = Schema.Struct({
-    step: Schema.Natural,
-    activePaths: Schema.Array(Schema.String),
-    candidateEvents: Schema.Array(Schema.String)
-});
-/**
- * Runtime behavior deliberately skipped by a best-effort step.
- *
- * @category schemas
- * @since 0.23.0
- */
-export const Note = Schema.Literals([
-    "runtime-effects-skipped",
-    "state-updates-skipped",
-    "reentry-lifecycles-skipped",
-    "automatic-transitions-skipped"
-]);
-const ResultFields = {
-    event: Schema.String,
-    transitionIds: Schema.Array(Schema.String),
-    session: Snapshot
-};
-/**
- * A topologically deterministic step.
- *
- * @category schemas
- * @since 0.23.0
- */
-export const Applied = Schema.Struct({
-    ...ResultFields,
-    _tag: Schema.tag("Applied"),
-    notes: Schema.Array(Note)
-});
-/**
- * An event with no registration in the current active configuration.
- *
- * @category schemas
- * @since 0.23.0
- */
-export const Blocked = Schema.Struct({
-    ...ResultFields,
-    _tag: Schema.tag("Blocked"),
-    reason: Schema.Literal("event-not-enabled")
-});
-/**
- * A step whose topology depends on runtime behavior the document cannot safely
- * evaluate.
- *
- * @category schemas
- * @since 0.23.0
- */
-export const Indeterminate = Schema.Struct({
-    ...ResultFields,
-    _tag: Schema.tag("Indeterminate"),
-    reason: Schema.Literals([
-        "multiple-transitions",
-        "declinable-transition",
-        "conditional-branches",
-        "history-target",
-        "choice-target",
-        "missing-target"
-    ])
-});
-/**
- * @category schemas
- * @since 0.23.0
- */
-export const StepResult = Schema.Union([Applied, Blocked, Indeterminate]);
-/**
- * Starts from the captured snapshot when present, otherwise from the static
- * initial topology.
- *
- * @category constructors
- * @since 0.23.0
- */
-export const start = internal.start;
-/**
- * Sends an event without running user code. `Applied` means the active topology
- * is statically known; its notes list runtime behavior that was skipped.
- *
- * @category combinators
- * @since 0.23.0
- */
-export const send = internal.send;
-//# sourceMappingURL=MachineSimulator.js.map

package/dist/MachineSimulator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MachineSimulator.js","sourceRoot":"","sources":["../src/MachineSimulator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,gCAAgC,CAAA;AAG1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC;IACpC,IAAI,EAAE,MAAM,CAAC,OAAO;IACpB,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;IACxC,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;CAC7C,CAAC,CAAA;AAmBF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC;IAClC,yBAAyB;IACzB,uBAAuB;IACvB,4BAA4B;IAC5B,+BAA+B;CAChC,CAAC,CAAA;AAQF,MAAM,YAAY,GAAG;IACnB,KAAK,EAAE,MAAM,CAAC,MAAM;IACpB,aAAa,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;IAC1C,OAAO,EAAE,QAAQ;CAClB,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,GAAG,YAAY;IACf,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;CAC1B,CAAC,CAAA;AAQF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,GAAG,YAAY;IACf,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,mBAAmB,CAAC;CAC5C,CAAC,CAAA;AAQF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC;IACzC,GAAG,YAAY;IACf,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC;QACtB,sBAAsB;QACtB,uBAAuB;QACvB,sBAAsB;QACtB,gBAAgB;QAChB,eAAe;QACf,gBAAgB;KACjB,CAAC;CACH,CAAC,CAAA;AAQF;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAA;AAQzE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,KAAK,GAA2D,QAAQ,CAAC,KAAK,CAAA;AAE3F;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAoD,QAAQ,CAAC,IAAI,CAAA"}