simulator/src

packages/simulator/src

Purpose

Code-first simulator API.

Public surface

`AgentConnection`

Interface

export interface AgentConnection<Name extends string = string> {
  readonly agent: AgentHandle<Name>;
}

Runtime identity issued for one scope-owned autonomous agent.

`AgentHandle`

Class

export class AgentHandle<
  Name extends string = string,
> extends ParticipantHandle<Name> {
  readonly [agentHandleTypeId] = agentHandleTypeId;

  private constructor(name: Name, id: AgentId) {
    super(name, id);
  }

  static [agentHandleConstruction]<const Name extends string>(
    name: Name,
    id: AgentId,
  ): AgentHandle<Name> {
    return new AgentHandle(name, id);
  }
}

A participant whose autonomous runtime is owned by the run scope.

`AgentProcessExited`

Class

export class AgentProcessExited extends Schema.TaggedClass<AgentProcessExited>()(
  "moltzap.agent-process-exited/v1",
  {
    agentName: agentName,
    agentId: agentId,
    runtime: Schema.NonEmptyString,
    code: Schema.NonNegativeInt,
  },
) {}

A roster runtime process terminated with an operating-system exit code.

`AgentProcessSignaled`

Class

export class AgentProcessSignaled extends Schema.TaggedClass<AgentProcessSignaled>()(
  "moltzap.agent-process-signaled/v1",
  {
    agentName: agentName,
    agentId: agentId,
    runtime: Schema.NonEmptyString,
    signal: Schema.NonEmptyString,
  },
) {}

A roster runtime process terminated because it received a signal.

`AgentRuntimeCompleted`

Class

export class AgentRuntimeCompleted extends Schema.TaggedClass<AgentRuntimeCompleted>()(
  "moltzap.agent-runtime-completed/v1",
  {
    agentName: agentName,
    agentId: agentId,
    runtime: Schema.NonEmptyString,
  },
) {}

An autonomous runtime completed normally.

`AgentRuntimeFailed`

Class

export class AgentRuntimeFailed extends Schema.TaggedClass<AgentRuntimeFailed>()(
  "moltzap.agent-runtime-failed/v1",
  {
    agentName: agentName,
    agentId: agentId,
    runtime: Schema.NonEmptyString,
    cause: Schema.NonEmptyString,
  },
) {}

An autonomous runtime completed with a recorded failure.

`AgentRuntimeReady`

Class

export class AgentRuntimeReady extends Schema.TaggedClass<AgentRuntimeReady>()(
  "moltzap.agent-runtime-ready/v1",
  {
    agentName: agentName,
    agentId: agentId,
    runtime: Schema.NonEmptyString,
  },
) {}

A roster runtime completed acquisition and readiness.

`AgentRuntimeStartFailed`

Class

export class AgentRuntimeStartFailed extends Schema.TaggedClass<AgentRuntimeStartFailed>()(
  "moltzap.agent-runtime-start-failed/v1",
  {
    agentName: agentName,
    runtime: Schema.NonEmptyString,
    cause: Schema.NonEmptyString,
  },
) {}

A roster runtime failed before it established readiness.

`AgentWorkspaceFileHarvested`

Class

export class AgentWorkspaceFileHarvested extends Schema.TaggedClass<AgentWorkspaceFileHarvested>()(
  "moltzap.agent-workspace-file/v1",
  {
    agentName: agentName,
    agentId: agentId,
    runtime: Schema.NonEmptyString,
    relativePath: Schema.NonEmptyString,
    outcome: harvestedFileOutcome,
  },
) {}

One workspace file read back from a live application after the customer program ended. relativePath is the experiment’s own name for the file, or the runtime’s label for a file it harvests on the experiment’s behalf.

`ClusterError`

Class

export class ClusterError extends Data.TaggedError("ClusterError")<{
  readonly detail: string;
}> {
  override get message(): string {
    return this.detail;
  }
}

Cluster loss that ends a run without exposing its backend.

`ClusterLost`

Class

export class ClusterLost<
  Definitions extends Readonly<Record<string, AgentRuntimeLike>>,
> extends Data.TaggedClass("ClusterLost")<{
  readonly cause: Cause.Cause<SimulatorRunFailure<Definitions>>;
  readonly receipt: LedgerReceipt;
}> {}

Post-allocation cluster error plus all durable evidence retained.

`ClusterServices`

TypeAlias

export type ClusterServices = LedgerStorage | RouterProvider | Cluster;

Opaque service set supplied by a local-Kubernetes or GKE Layer.

`CompletedLedgerReceipt`

Class

export class CompletedLedgerReceipt extends Schema.TaggedClass<CompletedLedgerReceipt>()(
  "CompletedLedgerReceipt",
  {
    ledger: ledgerRef,
    completion: LedgerCompletion,
  },
) {}

Physical receipt for a ledger whose completion marker is durable.

`coreEvents`

Variable

export const coreEvents = EventCatalog.merge(
  runEvents,
  routerEvents,
  runtimeEvents,
  linkEvents,
)

The exact event classes readable from every simulator run ledger.

`CustomerEvents`

Interface

export interface CustomerEvents<Catalog extends AnyEventCatalog> {
  readonly emit: (
    event: EventOf<Catalog>,
    metadata?: EventMetadata,
  ) => Effect.Effect<LedgerRecord<Catalog>, LedgerFailure>;
}

Definition-bound emission of customer-owned event classes only.

`EncodedEventOf`

TypeAlias

export type EncodedEventOf<Catalog> = Schema.Schema.Encoded<
  CatalogSchemaOf<Catalog>
>;

The closed encoded union persisted for a catalog.

`Endpoint`

Class

export class Endpoint<Name extends string = string> {
  readonly [endpointTypeId] = endpointTypeId;

  readonly participant: ParticipantHandle<Name>;
  private readonly inbox: EndpointInbox;
  private readonly transport: EndpointTransport;

  private constructor(
    participant: ParticipantHandle<Name>,
    transport: EndpointTransport,
    inbox: EndpointInbox,
  ) {
    this.participant = participant;
    this.transport = transport;
    this.inbox = inbox;
  }

  static [endpointConstruction]<const Name extends string>(
    attachment: AttachedEndpoint<Name>,
    inbox: EndpointInbox,
  ): Endpoint<Name> {
    return new Endpoint(attachment.participant, attachment.transport, inbox);
  }

  /**
   * Send one explicit addressed post through the endpoint daemon.
   * @param input Explicit destination and nonempty content.
   * @returns Completion after the daemon certifies the addressed post.
   */
  send(input: SendInput): Effect.Effect<void, NetworkError> {
    return this.transport.send(input);
  }

  /**
   * Observe addressed deliveries emitted after this stream is subscribed.
   * @returns A live fan-out stream of deliveries for this endpoint.
   */
  messages(): Stream.Stream<InboundDelivery, NetworkError> {
    return this.inbox.messages;
  }
}

A run-scoped participant controlled directly by the experiment program.

`EventCatalog`

Class

export class EventCatalog<
  SchemaType extends CatalogSchema,
  Classes extends EventClass = EventClass,
> {
  readonly schema: Schema.Schema<
    Schema.Schema.Type<SchemaType>,
    Schema.Schema.Encoded<SchemaType>
  >;
  readonly eventClasses: readonly EventClass[];
  readonly tags: readonly VersionedEventTag[];
  private readonly [eventCatalogTypeId] = eventCatalogTypeId;

  private constructor(schema: SchemaType, eventClasses: readonly EventClass[]) {
    this.schema = Schema.make<
      Schema.Schema.Type<SchemaType>,
      Schema.Schema.Encoded<SchemaType>
    >(schema.ast);
    this.eventClasses = Object.freeze([...eventClasses]);
    this.tags = Object.freeze(
      this.eventClasses.map((eventClass) => eventClass._tag),
    );
    Object.freeze(this);
  }

  static make<
    const EventClasses extends readonly [
      EventClass,
      ...(readonly EventClass[]),
    ],
  >(
    ...eventClasses: EventClasses
  ): EventCatalog<EventClassesSchema<EventClasses>, EventClasses[number]> {
    validateEventClasses(eventClasses);
    return new EventCatalog(makeEventClassesSchema(eventClasses), eventClasses);
  }

  static empty(): EventCatalog<Schema.Schema<never>, never> {
    const eventClasses: readonly never[] = [];
    return new EventCatalog(Schema.make<never>(Schema.Never.ast), eventClasses);
  }

  static merge<
    const Catalogs extends readonly [
      EventCatalog<CatalogSchema>,
      ...ReadonlyArray<EventCatalog<CatalogSchema>>,
    ],
  >(
    ...catalogs: Catalogs
  ): EventCatalog<
    MergedCatalogSchema<Catalogs>,
    CatalogClassesOf<Catalogs[number]>
  > {
    const eventClasses = catalogs.flatMap((catalog) => catalog.eventClasses);
    validateEventClasses(eventClasses);
    return new EventCatalog(mergeCatalogSchemas(catalogs), eventClasses);
  }

  has(eventClass: EventClass): eventClass is Classes {
    return this.eventClasses.some(
      (catalogEventClass) => catalogEventClass === eventClass,
    );
  }

  hasEvent(event: unknown): event is Schema.Schema.Type<SchemaType> {
    if (typeof event !== "object" || event === null) {
      return false;
    }
    const constructor: unknown = Reflect.get(event, "constructor");
    return this.eventClasses.some((eventClass) => eventClass === constructor);
  }

  decode(input: unknown) {
    return Schema.decodeUnknown(Schema.asSchema(this.schema))(input, {
      onExcessProperty: "error",
    });
  }

  encode(event: Schema.Schema.Type<SchemaType>) {
    return Schema.encode(Schema.asSchema(this.schema))(event, {
      onExcessProperty: "error",
    });
  }
}

The exact immutable event universe for one definition. The private type identifier makes catalog arguments nominal: a structural object cannot claim a schema, constructor list, and tag list that disagree.

`EventCatalogDefinitionError`

Class

export class EventCatalogDefinitionError extends Schema.TaggedError<EventCatalogDefinitionError>()(
  "EventCatalogDefinitionError",
  {
    failure: Schema.Literal("duplicate-tag", "invalid-tag"),
    tag: Schema.String,
  },
) {
  override get message(): string {
    return definitionFailureMessage[this.failure](this.tag);
  }
}

Invalid catalogs fail during definition construction, before a run starts.

`EventCatalogDefinitionFailure`

TypeAlias

export type EventCatalogDefinitionFailure = "duplicate-tag" | "invalid-tag";

Represents event catalog definition failure conditions.

`EventClass`

TypeAlias

export type EventClass = Schema.Schema.AnyNoContext & {
  readonly _tag: VersionedEventTag;
};

A schema-backed event constructor. The catalog retains both the schema and constructor faces so persisted values decode back into their exact class.

`EventClassOf`

TypeAlias

export type EventClassOf<Catalog> = CatalogClassesOf<Catalog>;

The closed constructor union declared by a catalog.

`EventMetadata`

Interface

export interface EventMetadata {
  readonly causationId?: string;
  readonly correlationId?: string;
}

Causality metadata accepted from a customer event producer.

`EventOf`

TypeAlias

export type EventOf<Catalog> = Schema.Schema.Type<CatalogSchemaOf<Catalog>>;

The closed instance union declared by a catalog.

`HarvestedFileOutcome`

TypeAlias

export type HarvestedFileOutcome = typeof harvestedFileOutcome.Type;

How the ledger records one read: the file’s text, its size when it ran past the bound, its absence, or why it could not be read.

`IncompleteLedgerReceipt`

Class

export class IncompleteLedgerReceipt extends Schema.TaggedClass<IncompleteLedgerReceipt>()(
  "IncompleteLedgerReceipt",
  {
    ledger: ledgerRef,
  },
) {}

Physical receipt retained when ledger completion could not be published.

`isEntryModule`

Function

export function isEntryModule(moduleUrl: string, invoked?: string): boolean

Whether a module is the process entry point rather than an ordinary import. Both sides are canonicalized because they are not the same kind of path: Node resolves a module’s real path before it becomes import.meta.url, while process.argv[1] is whatever the caller typed. Every executable in this package reaches its module through a symlink in the controller image, where /opt/moltzap/dist points at the installed package directory. Comparing the two without canonicalizing makes a directly invoked entry point look like an import, so the process exits successfully having done nothing. realPath returns undefined for a path that does not exist, so a missing or deleted argv[1] is a plain false rather than a thrown ENOENT. Returns: Whether both locations name the same real file.

`LedgerFailure`

TypeAlias

export type LedgerFailure =
  | LedgerStorageError
  | ParseResult.ParseError
  | LedgerSerializationError;

Represents ledger failure conditions.

`LedgerReceipt (type)`

TypeAlias

export type LedgerReceipt = typeof LedgerReceipt.Type;

Decoded physical ledger receipt.

`LedgerReceipt (value)`

Variable

export const LedgerReceipt = Schema.Union(
  CompletedLedgerReceipt,
  IncompleteLedgerReceipt,
)

Schema for the complete physical ledger-receipt universe.

`LinkController`

Class

export class LinkController extends Context.Tag(
  "@moltzap/simulator/LinkController",
)<LinkController, LinkControllerService>() {}

Experiment-facing directed-link control installed by the run kernel.

`LinkControllerService`

Interface

export interface LinkControllerService {
  /**
   * Keep one directed link disabled for the lifetime of the current Scope.
   * Overlapping acquisitions share a single physical down/up transition.
   */
  readonly disable: (
    from: ParticipantHandle,
    to: ParticipantHandle,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
  /** Delay every delivery on one directed link for the current Scope. */
  readonly delay: (
    from: ParticipantHandle,
    to: ParticipantHandle,
    duration: Duration.DurationInput,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
  /** Park every delivery on one directed link for the current Scope. */
  readonly hold: (
    from: ParticipantHandle,
    to: ParticipantHandle,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
  /** Install one custom policy on a directed link for the current Scope. */
  readonly shape: (
    from: ParticipantHandle,
    to: ParticipantHandle,
    policy: LinkPolicy,
    description: string,
  ) => Effect.Effect<void, NetworkError, LinkDriver | Scope.Scope>;
}

Run-scoped, evidence-producing directed-link control.

`LinkDelivery`

Interface

export interface LinkDelivery {
  /** Message sender identity. */
  readonly from: AgentId;
  /** Receiving participant identity. */
  readonly to: AgentId;
  /** Identity-owned opaque signed message carried by the delivery. */
  readonly message: SignedMessage;
}

One opaque signed message about to cross a directed link.

`LinkDown`

Class

export class LinkDown extends Schema.TaggedClass<LinkDown>()(
  "moltzap.link-down/v1",
  {
    from: agentId,
    to: agentId,
  },
) {}

A directed participant link transitioned from available to unavailable.

`linkPolicy`

Variable

export const linkPolicy:

Canonical link policies for the common traffic shapes.

`LinkPolicy`

TypeAlias

export type LinkPolicy = (delivery: LinkDelivery) => Effect.Effect<LinkVerdict>;

Decides one delivery on a directed link. A policy reads only its input and the ambient Clock; the link interpreter, never the policy, spends time and records evidence.

`LinkPolicyCleared`

Class

export class LinkPolicyCleared extends Schema.TaggedClass<LinkPolicyCleared>()(
  "moltzap.link-policy-cleared/v1",
  {
    from: agentId,
    to: agentId,
    policy: Schema.NonEmptyString,
  },
) {}

A described policy stopped shaping one directed participant link.

`LinkPolicySet`

Class

export class LinkPolicySet extends Schema.TaggedClass<LinkPolicySet>()(
  "moltzap.link-policy-set/v1",
  {
    from: agentId,
    to: agentId,
    policy: Schema.NonEmptyString,
  },
) {}

A described policy became active on one directed participant link.

`LinkUp`

Class

export class LinkUp extends Schema.TaggedClass<LinkUp>()("moltzap.link-up/v1", {
  from: agentId,
  to: agentId,
}) {}

A directed participant link transitioned from unavailable to available.

`linkVerdict`

Variable

export const linkVerdict = Data.taggedEnum<LinkVerdict>()

Constructors and matchers for the closed verdict union.

`LinkVerdict`

TypeAlias

export type LinkVerdict = Data.TaggedEnum<{
  deliver: Record<never, never>;
  drop: { readonly reason?: string };
  delay: { readonly duration: Duration.Duration };
  hold: Record<never, never>;
}>;

Closed per-delivery decision returned by a link policy.

`Network`

Class

export class Network extends Context.Tag("@moltzap/simulator/Network")<
  Network,
  NetworkService
>() {}

Network operations available to the customer program.

`NetworkError`

Class

export class NetworkError extends Schema.TaggedError<NetworkError>()(
  "NetworkError",
  {
    operation: networkOperation,
    detail: Schema.String,
  },
) {
  override get message(): string {
    return `Network ${this.operation} failed: ${this.detail}`;
  }
}

An operational failure at a simulator network boundary.

`NetworkService`

Interface

export interface NetworkService {
  endpoint<const Name extends string>(
    name: Name,
  ): Effect.Effect<Endpoint<Name>, NetworkError>;
}

Controlled endpoint operations installed for one run scope.

`ParticipantHandle`

Class

export class ParticipantHandle<Name extends string = string> {
  readonly [participantHandleTypeId] = participantHandleTypeId;

  readonly name: Name;
  readonly id: AgentId;

  protected constructor(name: Name, id: AgentId) {
    this.name = name;
    this.id = id;
  }

  static [participantHandleConstruction]<const Name extends string>(
    name: Name,
    id: AgentId,
  ): ParticipantHandle<Name> {
    return new ParticipantHandle(name, id);
  }
}

A network participant identity. The hidden symbol prevents structurally similar identity data from being used as a simulator handle.

`ProfileRunResult (type)`

TypeAlias

export type ProfileRunResult = typeof ProfileRunResult.Type;

Decoded form of the one result line moltzap-sim run prints.

`ProfileRunResult (value)`

Variable

export const ProfileRunResult = Schema.Struct({
  runId: Schema.NonEmptyString,
  namespace: Schema.NonEmptyString,
  result: controllerRunResult,
})

Schema of the final line moltzap-sim run prints for one submission. A consumer that spawns the executable decodes its stdout with this schema rather than copying the shape: the submitter is a separate process, so nothing else would notice the two sides disagreeing until a live run produced an undecodable line. The submitter’s own result type derives from this schema, so the two cannot drift.

`ProgramFailed`

Class

export class ProgramFailed extends Schema.TaggedClass<ProgramFailed>()(
  "moltzap.program-failed/v1",
  {
    cause: Schema.NonEmptyString,
  },
) {}

The customer program failed with a typed failure or defect.

`ProgramFinished`

Class

export class ProgramFinished<A, E> extends Data.TaggedClass("ProgramFinished")<{
  readonly exit: Exit.Exit<A, E>;
  readonly receipt: CompletedLedgerReceipt;
}> {}

Customer-program completion plus its complete durable evidence.

`ProgramInterrupted`

Class

export class ProgramInterrupted extends Schema.TaggedClass<ProgramInterrupted>()(
  "moltzap.program-interrupted/v1",
  {
    cause: Schema.NonEmptyString,
  },
) {}

The customer program was interrupted.

`ProgramSucceeded`

Class

export class ProgramSucceeded extends Schema.TaggedClass<ProgramSucceeded>()(
  "moltzap.program-succeeded/v1",
  {},
) {}

The customer program returned successfully.

`ReadableRunLedger`

Interface

export interface ReadableRunLedger<Catalog extends AnyEventCatalog> {
  readonly ref: LedgerRef;
  readonly manifest: LedgerManifest;
  readonly records: Stream.Stream<LedgerRecord<Catalog>, LedgerFailure>;
  readonly events: <Event extends EventClassOf<Catalog>>(
    eventClass: Event,
  ) => Stream.Stream<Schema.Schema.Type<Event>, LedgerFailure>;
}

Definition-bound read access to every committed core and customer event.

`RouterStarted`

Class

export class RouterStarted extends Schema.TaggedClass<RouterStarted>()(
  "moltzap.router-started/v1",
  {
    routerUrl: Schema.URL,
  },
) {}

The run-scoped Router is accepting participant connections.

`RouterStartFailed`

Class

export class RouterStartFailed extends Schema.TaggedClass<RouterStartFailed>()(
  "moltzap.router-start-failed/v1",
  {
    cause: Schema.NonEmptyString,
  },
) {}

Router acquisition failed before the data plane became available.

`RouterStopFailed`

Class

export class RouterStopFailed extends Schema.TaggedClass<RouterStopFailed>()(
  "moltzap.router-stop-failed/v1",
  {
    cause: Schema.NonEmptyString,
  },
) {}

Router release or stopped-Router evidence collection failed.

`Run`

Variable

export const Run: Readonly<{ execute: typeof executeRunSpec }> = Object.freeze({
  execute: executeRunSpec,
})

Discoverable execution entry point for one experiment society.

`RunSpec (type)`

Interface

export interface RunSpec<
  Id extends SimulatorDefinitionId = SimulatorDefinitionId,
  CustomerCatalogs extends
    readonly AnyEventCatalog[] = readonly AnyEventCatalog[],
  Definitions extends Readonly<Record<string, AgentRuntimeLike>> = Readonly<
    Record<string, AgentRuntimeLike>
  >,
  A = unknown,
  E = unknown,
  R = never,
  ClusterLayer extends Layer.Layer<
    never,
    unknown,
    unknown
  > = Layer.Layer<ClusterServices>,
> {
  /**
   * Present only on the exact values RunSpec.define produced, and carrying
   * their runner. This is the one identity gate: nothing structural
   * distinguishes a definition from a lookalike, and a lookalike has no
   * runner to invoke.
   */
  readonly [runSpecTypeId]?: () => RunSpecExecution<
    Id,
    CustomerCatalogs,
    Definitions,
    A,
    E,
    R,
    ClusterLayer
  >;
  readonly id: Id;
  readonly events: CustomerCatalogs;
  readonly agents: Definitions;
  readonly cluster: ClusterLayer &
    Layer.Layer<
      ClusterServices,
      Layer.Layer.Error<ClusterLayer>,
      Layer.Layer.Context<ClusterLayer>
    >;
  readonly execute: (
    context: RunExecutionContext<Id, CustomerCatalogs, Definitions>,
  ) => Effect.Effect<A, E, R>;
}

Immutable code-first definition of one experiment society.

`RunSpec (value)`

Variable

export const RunSpec: Readonly<{ define: typeof defineRunSpec }> =
  Object.freeze({ define: defineRunSpec })

Discoverable constructor for immutable experiment definitions.

`RunStarted`

Class

export class RunStarted extends Schema.TaggedClass<RunStarted>()(
  "moltzap.run-started/v1",
  {
    definitionId: Schema.NonEmptyString,
  },
) {}

The run ledger is allocated and run-scoped acquisition has begun.

`SimulatorDefinitionError`

Class

export class SimulatorDefinitionError extends Schema.TaggedError<SimulatorDefinitionError>()(
  "SimulatorDefinitionError",
  {
    definitionId: Schema.String,
    detail: Schema.NonEmptyString,
  },
) {
  override get message(): string {
    return `Simulator definition "${this.definitionId}" is invalid: ${this.detail}`;
  }
}

Reports simulator definition failures.

`SimulatorDefinitionId`

TypeAlias

export type SimulatorDefinitionId = `${string}.${string}/v${number}`;

Stable code identity persisted in every ledger manifest.

`SimulatorRunFailure`

TypeAlias

export type SimulatorRunFailure<
  Definitions extends Readonly<Record<string, AgentRuntimeLike>>,
> =
  | AgentRosterAcquisitionError<Definitions>
  | ClusterError
  | LedgerFailure
  | NetworkError;

Represents simulator run failure conditions.

`SimulatorRunOutcome`

TypeAlias

export type SimulatorRunOutcome<
  A,
  E,
  Definitions extends Readonly<Record<string, AgentRuntimeLike>>,
> = ProgramFinished<A, E> | ClusterLost<Definitions>;

Closed result of every run whose ledger allocation succeeded.

`VersionedEventTag`

TypeAlias

export type VersionedEventTag = `${string}.${string}/v${number}`;

Stable persisted identity for an event class.

Files

agents/agent.ts
agents/container.ts
agents/index.ts
agents/nanoclaw/gateway.ts
agents/nanoclaw/runtime.ts
agents/openclaw/configuration.ts
agents/openclaw/gateway.ts
agents/openclaw/runtime.ts
agents/roster.ts
agents/workspace.ts
cluster/bootstrap.ts
cluster/cluster.ts
cluster/cohort.ts
cluster/controlled-endpoint.ts
cluster/controller/configuration.ts
cluster/controller/ledger-export.ts
cluster/controller/main.ts
cluster/controller/services.ts
cluster/controller/summary.ts
cluster/entry.ts
cluster/install.ts
cluster/kubernetes/calls.ts
cluster/kubernetes/harvest.ts
cluster/kubernetes/network-objects.ts
cluster/kubernetes/objects.ts
cluster/profile.ts
cluster/profiles/cli.ts
cluster/profiles/gke.ts
cluster/profiles/local.ts
cluster/profiles/result.ts
cluster/reclaim.ts
cluster/scaffold.ts
cluster/society-network.ts
cluster/submit.ts
cluster/temporal.ts
cluster/watch.ts
definition.ts
events/catalog.ts
events/core.ts
index.ts
ledger/append.ts
ledger/filesystem.ts
ledger/index.ts
ledger/read.ts
ledger/schema.ts
ledger/storage.ts
network/endpoint.ts
network/failure.ts
network/index.ts
network/link.ts
network/participant.ts
network/router.ts
run/acquire.ts
run/endpoints.ts
run/events.ts
run/execute.ts
run/link-fabric.ts
run/links.ts
run/outcomes.ts
run/router-fault-proxy.ts

​simulator/src

​Purpose

​Public surface

​Files

simulator/src

Purpose

Public surface

Files