@almadar/shell-runtime 0.1.0 → 1.1.0

package/dist/chunk-D4XJTBLB.js

@@ -1,217 +0,0 @@
-import { declareCapabilities, answerRequest } from './chunk-NATGCIVM.js';
-import { DispatchLane } from './chunk-53IPZXDP.js';
-import { decodeResolveProgress, decodeProgress } from './chunk-RBUMDYFS.js';
-import { installKernelEvaluator, MountSeedSchema, EventStreamItemSchema, isEntityReferenceAny } from '@almadar/core';
-
-function declaredEntityTypes(schema) {
-  return schema.orbitals.flatMap((orbital) => [orbital.entity, ...orbital.auxiliaryEntities ?? []].flatMap((entity) => isEntityReferenceAny(entity) ? [] : [entity.name]));
-}
-var KernelEngine = class _KernelEngine {
-  constructor(kernel, schemaJson, ports, entityTypes = [], forkedFrom, providedHandle, preserveProgramContext = false) {
-    this.kernel = kernel;
-    this.schemaJson = schemaJson;
-    this.ports = ports;
-    this.entityTypes = entityTypes;
-    this.preserveProgramContext = preserveProgramContext;
-    installKernelEvaluator(kernel);
-    this.ports = {
-      ...ports,
-      substrateMessage: (site, key, value) => JSON.parse(kernel.osCompletionEvent(JSON.stringify({ ...site, emit: { success: site.emit.onMessage } }), key, JSON.stringify({ ok: value }))),
-      substrateCompletion: (site, key, op, args, outcome) => JSON.parse(kernel.substrateCompletionEvent(JSON.stringify(site), key, op, JSON.stringify(args), JSON.stringify(outcome)))
-    };
-    this.handle = providedHandle ?? forkedFrom?.fork() ?? this.openServer();
-    this.declare();
-  }
-  kernel;
-  schemaJson;
-  ports;
-  entityTypes;
-  preserveProgramContext;
-  handle;
-  lane = new DispatchLane();
-  tickMount = [];
-  messages = { locales: [], catalogs: {} };
-  /**
-   * A kernel on the same program, registered once, holding none of this one's session: every trait at its initial
-   * state, no rows the kernel held, its locales and mounted ticks kept. A stateless host serves each request a
-   * fork (EXEC-DIST-5), `ports` answering it.
-   */
-  fork(ports = this.ports) {
-    const forked = new _KernelEngine(this.kernel, this.schemaJson, ports, this.entityTypes, this.handle, void 0, this.preserveProgramContext);
-    forked.tickMount = this.tickMount;
-    forked.messages = this.messages;
-    return forked;
-  }
-  forkProgram(program, ports = this.ports) {
-    const schemaJson = JSON.stringify(program);
-    const entityTypes = [.../* @__PURE__ */ new Set([
-      ...this.entityTypes,
-      ...declaredEntityTypes(program)
-    ])];
-    return new _KernelEngine(this.kernel, schemaJson, ports, entityTypes, void 0, this.handle.forkProgram(schemaJson), true);
-  }
-  /** A server over the host's ports. */
-  openServer() {
-    return new this.kernel.Server(this.schemaJson);
-  }
-  declare() {
-    const handle = this.handle;
-    declareCapabilities(this.ports.persistence, (entityType, queryJson, writeJson) => handle.setCapabilities(entityType, queryJson, writeJson), this.entityTypes);
-  }
-  static open(kernel, schema, ports) {
-    return new _KernelEngine(kernel, JSON.stringify(schema), ports, declaredEntityTypes(schema));
-  }
-  /** A fresh kernel on the same program: every trait back at its initial state. */
-  reset() {
-    const contextualHandle = this.preserveProgramContext ? this.handle.fork() : void 0;
-    this.handle.free();
-    this.handle = contextualHandle ?? this.openServer();
-    this.declare();
-    this.handle.setTickMount(JSON.stringify(this.tickMount));
-    this.handle.setMessages(JSON.stringify(this.messages.locales), JSON.stringify(this.messages.catalogs));
-    if (this.managedProgram !== void 0) this.handle.setManagedProgram(this.managedProgram);
-  }
-  managedProgram;
-  /** The program whose declared credentials this kernel's credential effects manage beside its own (a console's app). */
-  setManagedProgram(program) {
-    this.managedProgram = JSON.stringify(program);
-    this.handle.setManagedProgram(this.managedProgram);
-  }
-  /** The program's declared locales and merged catalogs (a lazy page's behavior contributes its namespaced keys). */
-  setMessages(locales, catalogs) {
-    this.messages = { locales, catalogs };
-    this.handle.setMessages(JSON.stringify(locales), JSON.stringify(catalogs));
-  }
-  /** The traits some client has mounted: a tick that is not `[background]` fires only for these. */
-  setTickMount(traits) {
-    this.tickMount = traits;
-    this.handle.setTickMount(JSON.stringify(traits));
-  }
-  /** What this host mounts when it starts: the kernel's boot mounts for the side it serves (EXEC-ENDPOINT-3). */
-  bootMounts(side) {
-    return MountSeedSchema.array().parse(JSON.parse(this.handle.bootMounts(side)));
-  }
-  /** What mounts when a client opens `routePath` (EXEC-ENDPOINT-3). */
-  routeMounts(routePath) {
-    return MountSeedSchema.array().parse(JSON.parse(this.handle.routeMounts(routePath)));
-  }
-  /** Mock-seed the `[runtime]` entities the kernel holds itself, owner columns stamped with `viewerId`. */
-  seedRuntimeMock(viewerId) {
-    this.handle.seedRuntimeMock(viewerId);
-  }
-  dispose() {
-    this.handle.free();
-  }
-  liveItemDelivered(item, viewer, clientId) {
-    return this.handle.liveItemDelivered(JSON.stringify(item), JSON.stringify(viewer), clientId);
-  }
-  /** `OsGrants::allows` over the grants of the program this kernel runs. */
-  osAllows(requirementJson) {
-    return this.handle.osAllows(requirementJson);
-  }
-  /** Place the program's anchored grants and arguments under the host's anchors. */
-  setOsAnchors(anchorsJson) {
-    return this.handle.setOsAnchors(anchorsJson);
-  }
-  /** An `os/` call's arguments with its anchored parts resolved under the host's anchors. */
-  osResolveArgs(op, argsJson) {
-    return this.handle.osResolveArgs(op, argsJson);
-  }
-  /** The current state of a trait instance, `''` when it has none. */
-  stateOf(traitName, entityId) {
-    return this.handle.getState(traitName, entityId);
-  }
-  /**
-   * `reference` resolved for `scope.user` against the host-answered store (EXEC-RENDER-3): the rows that still
-   * match its query and the viewer's `@read` in the reference's order, a missing or hidden row omitted, and `total`
-   * re-counted (a `total: none` reference is not re-counted: the total is the resolved window). Each read the
-   * kernel makes is answered here, as in `evaluate`.
-   */
-  async resolveRows(reference, scope) {
-    const handle = this.handle;
-    let progress = decodeResolveProgress(handle.resolveRows(JSON.stringify(reference), JSON.stringify(scope.user ?? null)));
-    while (progress.status === "await") {
-      const { flight, requests } = progress;
-      let replies;
-      try {
-        replies = await Promise.all(
-          requests.map(async (pending) => ({ id: pending.id, answer: await answerRequest(this.ports, pending.request, scope) }))
-        );
-      } catch (error) {
-        handle.abandon(flight);
-        throw error;
-      }
-      progress = decodeResolveProgress(handle.resumeResolve(flight, JSON.stringify(replies)));
-    }
-    return { rows: progress.rows, total: progress.total };
-  }
-  /** Run `request` against `orbital`: start it, answer every request the kernel asks for, resume until done. */
-  async evaluate(orbital, request, scope) {
-    const guard = await this.lane.enter();
-    try {
-      const handle = this.handle;
-      let progress = decodeProgress(handle.start(orbital, JSON.stringify(request)));
-      while (progress.status === "await") {
-        const { flight, requests } = progress;
-        let replies;
-        guard.park(request.event);
-        try {
-          replies = await Promise.all(
-            requests.map(async (pending) => ({ id: pending.id, answer: await answerRequest(this.ports, pending.request, { ...scope, assertReentry: () => this.lane.assertCanReenter(guard.turn) }) }))
-          );
-        } catch (error) {
-          handle.abandon(flight);
-          throw error;
-        }
-        guard.resume();
-        progress = decodeProgress(handle.resume(flight, JSON.stringify(replies)));
-      }
-      if (scope.onStream !== void 0) {
-        const items = EventStreamItemSchema.array().parse(JSON.parse(handle.dispatchStream()));
-        for (const item of items) scope.onStream(item);
-      }
-      return progress.response;
-    } finally {
-      guard.release();
-    }
-  }
-};
-function kernelRequest(request, user, locale) {
-  const { _activeTraits: _dropped, _targetTrait: sidecarTarget, ...rest } = request.payload ?? {};
-  const payload = rest;
-  const target = request.targetTrait ?? (typeof sidecarTarget === "string" ? sidecarTarget : void 0);
-  const { payload: _payload, ...others } = request;
-  return {
-    ...others,
-    ...request.payload !== void 0 ? { payload } : {},
-    ...target !== void 0 ? { targetTrait: target } : {},
-    ...user !== void 0 ? { user } : {},
-    ...locale !== void 0 ? { locale } : {}
-  };
-}
-function withOriginClient(response, clientId) {
-  if (clientId === void 0) return response;
-  return {
-    ...response,
-    emittedEvents: response.emittedEvents.map((emitted) => emitted.source === void 0 ? emitted : { ...emitted, source: { ...emitted.source, originClientId: emitted.source.originClientId ?? clientId } })
-  };
-}
-async function evaluateOnKernel(kernel, request, user, locale) {
-  return withOriginClient(await kernel.engine.evaluate(kernel.orbital, kernelRequest(request, user, locale), {
-    orbital: kernel.orbital,
-    ...user !== void 0 ? { user } : {},
-    ...request.clientId !== void 0 ? { originClientId: request.clientId } : {},
-    ...locale !== void 0 ? { locale } : {},
-    ...request.entityId !== void 0 ? { entityId: request.entityId } : {},
-    ...kernel.onStream !== void 0 ? { onStream: (item) => {
-      if (item.type === "event" && item.data.source !== void 0 && request.clientId !== void 0) {
-        kernel.onStream?.({ ...item, data: { ...item.data, source: { ...item.data.source, originClientId: item.data.source.originClientId ?? request.clientId } } });
-      } else if (item.type === "complete") {
-        kernel.onStream?.({ ...item, data: withOriginClient(item.data, request.clientId) });
-      } else kernel.onStream?.(item);
-    } } : {},
-    ...kernel.outsideEventQueue !== void 0 ? { outsideEventQueue: kernel.outsideEventQueue } : {}
-  }), request.clientId);
-}
-
-export { KernelEngine, evaluateOnKernel, kernelRequest };

package/dist/chunk-D5USD2EX.js

@@ -1,232 +0,0 @@
-import { createHttpTransport } from './chunk-QELZ6TEJ.js';
-import { createLogger } from '@almadar/logger';
-
-var log = createLogger("almadar:runtime:server-bridge");
-var ServerBridge = class {
-  config;
-  state = {
-    connected: false,
-    eventsForwarded: 0,
-    eventsReceived: 0
-  };
-  unsubscribes = [];
-  pollTimer;
-  ws;
-  fetchFn;
-  /** The one HTTP request/response leg — shared with `@almadar/ui`'s transport (P5, EventTransport.ts). */
-  transport;
-  constructor(config) {
-    this.config = {
-      pollInterval: 5e3,
-      ...config
-    };
-    this.fetchFn = config.fetch || fetch.bind(globalThis);
-    this.transport = createHttpTransport({ serverUrl: config.serverUrl, fetch: this.fetchFn });
-  }
-  // ==========================================================================
-  // Connection Management
-  // ==========================================================================
-  /**
-   * Connect the bridge - start forwarding events
-   */
-  connect() {
-    if (this.state.connected) {
-      this.log("warn", "Already connected");
-      return;
-    }
-    this.log("info", "Connecting bridge...");
-    this.setupEventForwarding();
-    if (this.config.useWebSocket) {
-      this.setupWebSocket();
-    } else if (this.config.pollInterval && this.config.pollInterval > 0) {
-      this.setupPolling();
-    }
-    this.state.connected = true;
-    this.log("info", "Bridge connected");
-  }
-  /**
-   * Disconnect the bridge
-   */
-  disconnect() {
-    for (const unsub of this.unsubscribes) {
-      unsub();
-    }
-    this.unsubscribes = [];
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = void 0;
-    }
-    if (this.ws) {
-      this.ws.close();
-      this.ws = void 0;
-    }
-    this.state.connected = false;
-    this.log("info", "Bridge disconnected");
-  }
-  /**
-   * Get current bridge state
-   */
-  getState() {
-    return { ...this.state };
-  }
-  // ==========================================================================
-  // Event Forwarding (Client -> Server)
-  // ==========================================================================
-  setupEventForwarding() {
-    const { eventBus, forwardEvents, forwardPattern } = this.config;
-    if (forwardEvents && forwardEvents.length > 0) {
-      for (const eventType of forwardEvents) {
-        const unsub = eventBus.on(eventType, (event) => {
-          this.forwardToServer(event);
-        });
-        this.unsubscribes.push(unsub);
-      }
-    } else if (forwardPattern) {
-      if (forwardPattern === "*") {
-        const unsub = eventBus.on("*", (event) => {
-          if (!event.type.startsWith("UI:") && !event.type.startsWith("BRIDGE:")) {
-            this.forwardToServer(event);
-          }
-        });
-        this.unsubscribes.push(unsub);
-      } else {
-        const prefix = forwardPattern.replace("*", "");
-        const unsub = eventBus.on("*", (event) => {
-          if (event.type.startsWith(prefix)) {
-            this.forwardToServer(event);
-          }
-        });
-        this.unsubscribes.push(unsub);
-      }
-    }
-  }
-  async forwardToServer(event) {
-    const { serverUrl, targetOrbital } = this.config;
-    try {
-      if (targetOrbital && targetOrbital !== "broadcast") {
-        await this.sendEventToOrbital(targetOrbital, event);
-      } else {
-        const orbitals = await this.fetchOrbitals();
-        for (const orbital of orbitals) {
-          await this.sendEventToOrbital(orbital.name, event);
-        }
-      }
-      this.state.eventsForwarded++;
-      this.log("debug", `Forwarded event: ${event.type}`);
-    } catch (error) {
-      this.state.lastError = String(error);
-      this.log("error", `Failed to forward event: ${event.type}`, error instanceof Error ? error : String(error));
-    }
-  }
-  async sendEventToOrbital(orbitalName, event) {
-    const request = { event: event.type, payload: event.payload };
-    const result = await this.transport.send(orbitalName, request);
-    if (result.emittedEvents && result.emittedEvents.length > 0) {
-      for (const emitted of result.emittedEvents) {
-        this.config.eventBus.emit(`SERVER:${emitted.event}`, emitted.payload);
-        this.state.eventsReceived++;
-      }
-    }
-  }
-  async fetchOrbitals() {
-    const response = await this.fetchFn(this.config.serverUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch orbitals: ${response.status}`);
-    }
-    const data = await response.json();
-    return data.orbitals || [];
-  }
-  // ==========================================================================
-  // Server -> Client (Polling)
-  // ==========================================================================
-  setupPolling() {
-    this.log("debug", "Polling mode - events received via forward response");
-  }
-  // ==========================================================================
-  // Server -> Client (WebSocket)
-  // ==========================================================================
-  setupWebSocket() {
-    const { serverUrl } = this.config;
-    const wsUrl = serverUrl.replace(/^http:/, "ws:").replace(/^https:/, "wss:").replace(/\/api\/orbitals$/, "/ws/orbitals");
-    try {
-      this.ws = new WebSocket(wsUrl);
-      this.ws.onopen = () => {
-        this.log("info", "WebSocket connected");
-      };
-      this.ws.onmessage = (msg) => {
-        try {
-          const data = JSON.parse(msg.data);
-          if (data.type === "event") {
-            this.config.eventBus.emit(`SERVER:${data.event}`, data.payload);
-            this.state.eventsReceived++;
-            this.log("debug", `Received server event: ${data.event}`);
-          }
-        } catch (error) {
-          this.log("error", "Failed to parse WebSocket message", error instanceof Error ? error : String(error));
-        }
-      };
-      this.ws.onerror = (error) => {
-        this.state.lastError = "WebSocket error";
-        this.log("error", "WebSocket error", error);
-      };
-      this.ws.onclose = () => {
-        this.log("info", "WebSocket closed");
-      };
-    } catch (error) {
-      this.log("error", "Failed to create WebSocket", error instanceof Error ? error : String(error));
-    }
-  }
-  // ==========================================================================
-  // Direct Methods
-  // ==========================================================================
-  /**
-   * Send an event directly to a specific orbital (bypassing EventBus)
-   */
-  async sendEvent(orbitalName, event, payload) {
-    try {
-      const result = await this.transport.send(orbitalName, { event, payload });
-      return {
-        success: result.success,
-        states: result.states,
-        emittedEvents: result.emittedEvents,
-        error: result.error
-      };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  }
-  /**
-   * Get current state of an orbital's traits
-   */
-  async getOrbitalState(orbitalName) {
-    const { serverUrl } = this.config;
-    const url = `${serverUrl}/${orbitalName}`;
-    try {
-      const response = await this.fetchFn(url);
-      const data = await response.json();
-      if (data.success && data.orbital) {
-        const states = {};
-        for (const trait of data.orbital.traits) {
-          states[trait.name] = trait.currentState;
-        }
-        return { success: true, states };
-      }
-      return { success: false, error: data.error };
-    } catch (error) {
-      return { success: false, error: String(error) };
-    }
-  }
-  // ==========================================================================
-  // Utilities
-  // ==========================================================================
-  log(level, message, data) {
-    if (!this.config.debug && level === "debug") return;
-    const meta = data === void 0 ? {} : data instanceof Error ? { error: data } : { detail: typeof data === "string" ? data : JSON.stringify(data) };
-    log[level](message, meta);
-  }
-};
-function createServerBridge(config) {
-  return new ServerBridge(config);
-}
-
-export { ServerBridge, createServerBridge };

package/dist/chunk-EV56K4GB.js

@@ -1,63 +0,0 @@
-// src/runtime/effects/composition/layout-strategy.ts
-function hasSequentialChain(wiring) {
-  if (wiring.length < 2) {
-    return false;
-  }
-  const adjacency = /* @__PURE__ */ new Map();
-  const allTargets = /* @__PURE__ */ new Set();
-  for (const entry of wiring) {
-    let targets = adjacency.get(entry.from);
-    if (!targets) {
-      targets = /* @__PURE__ */ new Set();
-      adjacency.set(entry.from, targets);
-    }
-    targets.add(entry.to);
-    allTargets.add(entry.to);
-  }
-  const roots = [];
-  for (const from of adjacency.keys()) {
-    if (!allTargets.has(from)) {
-      roots.push(from);
-    }
-  }
-  const starts = roots.length > 0 ? roots : [...adjacency.keys()];
-  for (const start of starts) {
-    let current = start;
-    let length = 1;
-    const visited = /* @__PURE__ */ new Set([current]);
-    while (true) {
-      const nexts = adjacency.get(current);
-      if (!nexts || nexts.size === 0) break;
-      let advanced = false;
-      for (const next of nexts) {
-        if (!visited.has(next)) {
-          visited.add(next);
-          current = next;
-          length++;
-          advanced = true;
-          break;
-        }
-      }
-      if (!advanced) break;
-    }
-    if (length >= 3) {
-      return true;
-    }
-  }
-  return false;
-}
-function detectLayoutStrategy(orbitals, eventWiring) {
-  if (eventWiring && eventWiring.length > 0 && hasSequentialChain(eventWiring)) {
-    return "wizard-flow";
-  }
-  const count = orbitals.length;
-  if (count <= 1) {
-    return "single";
-  }
-  if (count <= 4) {
-    return "tabs";
-  }
-  return "sidebar";
-}
-
-export { detectLayoutStrategy };

package/dist/chunk-FQ6IZMIU.js

@@ -1,10 +0,0 @@
-// src/runtime/effects/composition/pipe.ts
-function pipeBehaviors(seed, ...steps) {
-  let current = seed;
-  for (const step of steps) {
-    current = step(current);
-  }
-  return current;
-}
-
-export { pipeBehaviors };

package/dist/chunk-HMK6YMQS.js

@@ -1,135 +0,0 @@
-import { eventPayloadOf, isInlineTrait, normalizeCallSiteConfigToValues, JsonValueSchema, isJsonObject, EntityRowSchema, orbitalInlineEntities } from '@almadar/core';
-import { ownerFieldsFromSchema } from '@almadar/core/mock';
-
-// src/runtime/entities/std-mock-seed.ts
-var SEED_ORBITAL = "MockSeedOrbital";
-var SEED_TRAIT = "MockSeed";
-function asJson(value) {
-  return JsonValueSchema.parse(JSON.parse(JSON.stringify(value)));
-}
-function fieldOf(value, name, what) {
-  if (value === void 0 || !isJsonObject(value)) throw new Error(`std-mock-seed: ${what} is not an object`);
-  const found = value[name];
-  if (found === void 0) throw new Error(`std-mock-seed: ${what} has no ${name}`);
-  return found;
-}
-function textOf(value, what) {
-  if (typeof value !== "string") throw new Error(`std-mock-seed: ${what} is not a string`);
-  return value;
-}
-function cellOf(value) {
-  return {
-    store: textOf(fieldOf(value, "store", "owner cell"), "cell store"),
-    id: textOf(fieldOf(value, "id", "owner cell"), "cell id"),
-    column: textOf(fieldOf(value, "column", "owner cell"), "cell column")
-  };
-}
-function cellsOf(value, what) {
-  if (!Array.isArray(value)) throw new Error(`std-mock-seed: ${what} is not an array`);
-  return value.map(cellOf);
-}
-function journalOf(value) {
-  return {
-    viewerId: textOf(fieldOf(value, "viewerId", "journal"), "journal viewerId"),
-    stamped: cellsOf(fieldOf(value, "stamped", "journal"), "journal stamped"),
-    deferred: cellsOf(fieldOf(value, "deferred", "journal"), "journal deferred")
-  };
-}
-function changeOf(value) {
-  const kind = fieldOf(value, "kind", "owner change");
-  if (kind !== "set" && kind !== "rekey") throw new Error("std-mock-seed: owner change kind is neither set nor rekey");
-  return { ...cellOf(value), kind, ownerId: textOf(fieldOf(value, "ownerId", "owner change"), "change ownerId") };
-}
-function storesOf(value) {
-  if (!isJsonObject(value)) throw new Error("std-mock-seed: dataset stores is not an object");
-  return Object.fromEntries(Object.entries(value).map(([store, rows]) => [store, EntityRowSchema.array().parse(rows)]));
-}
-function ownerPairsOf(schema) {
-  return ownerFieldsFromSchema(schema).map((field) => {
-    const dot = field.indexOf(".");
-    if (dot <= 0 || dot === field.length - 1) throw new Error(`std-mock-seed: owner field ${field} is not Entity.column`);
-    return { entity: field.slice(0, dot), column: field.slice(dot + 1) };
-  });
-}
-var StdMockSeed = class {
-  constructor(engine, config, user) {
-    this.engine = engine;
-    this.config = config;
-    this.user = user;
-  }
-  engine;
-  config;
-  user;
-  async ask(event, payload, done) {
-    const response = await this.engine.evaluate(
-      SEED_ORBITAL,
-      { event, targetTrait: SEED_TRAIT, payload: eventPayloadOf(asJson(payload)) },
-      { orbital: SEED_ORBITAL, ...this.user !== void 0 ? { user: this.user } : {} }
-    );
-    const failed = response.emittedEvents.find((emitted) => emitted.event === "DATASET_FAILED");
-    if (failed !== void 0) throw new Error(`std-mock-seed: ${event} refused: ${JSON.stringify(failed.payload ?? {})}`);
-    const answer = response.emittedEvents.find((emitted) => emitted.event === done);
-    if (answer === void 0) throw new Error(`std-mock-seed: ${event} did not answer ${done}`);
-    return asJson(answer.payload ?? {});
-  }
-  /** Sample the program's dataset (`DATASET_INPUT`). */
-  async dataset(program, run) {
-    const done = await this.ask("DATASET_INPUT", {
-      program,
-      count: this.config.count,
-      seed: this.config.seed,
-      nowMs: run.nowMs,
-      viewerId: run.viewerId ?? "",
-      ownerPairs: ownerPairsOf(program),
-      ...run.locale !== void 0 ? { locale: run.locale } : {}
-    }, "DATASET_DONE");
-    return { stores: storesOf(fieldOf(done, "stores", "DATASET_DONE")), journal: journalOf(fieldOf(done, "journal", "DATASET_DONE")) };
-  }
-  /**
-   * Re-point the dataset's tracked owner cells at `viewer` (`RESTAMP_INPUT`); `stores` are the current authoritative rows.
-   * `firstOwner` marks the stamp right after seeding; a persona switch restamps only when the program's
-   * `restampOnPersona` config says so, otherwise it answers no changes.
-   */
-  async restamp(program, stores, journal, viewer, firstOwner) {
-    const done = await this.ask("RESTAMP_INPUT", { program, stores, journal, viewer, firstOwner, restampOnPersona: this.config.restampOnPersona }, "RESTAMP_DONE");
-    const changes = fieldOf(done, "changes", "RESTAMP_DONE");
-    if (!Array.isArray(changes)) throw new Error("std-mock-seed: RESTAMP_DONE changes is not an array");
-    return { journal: journalOf(fieldOf(done, "journal", "RESTAMP_DONE")), changes: changes.map(changeOf) };
-  }
-};
-var STD_MOCK_SEED_SOURCE = "std/behaviors/std-mock-seed";
-var SEED_TRAIT_REF = "traits.MockSeed";
-function declaredValue(values, key, is) {
-  const value = values[key];
-  if (value === void 0 || !is(value)) throw new Error(`std-mock-seed: config ${key} is not declared as expected`);
-  return value;
-}
-function declaredSeedConfig(seedProgram, app) {
-  const seedTrait = seedProgram.orbitals.flatMap((orbital) => orbital.traits ?? []).find((t) => isInlineTrait(t) && t.name === SEED_TRAIT);
-  if (seedTrait === void 0 || !isInlineTrait(seedTrait)) throw new Error(`std-mock-seed: the seed program has no ${SEED_TRAIT} trait`);
-  const composed = (app?.orbitals ?? []).flatMap((orbital) => {
-    const aliases = (orbital.uses ?? []).filter((u) => u.from === STD_MOCK_SEED_SOURCE).map((u) => u.as);
-    return (orbital.traits ?? []).flatMap((t) => typeof t !== "string" && !isInlineTrait(t) && aliases.some((alias) => t.ref === `${alias}.${SEED_TRAIT_REF}`) ? [normalizeCallSiteConfigToValues(t.config) ?? {}] : []);
-  });
-  const values = Object.assign({}, normalizeCallSiteConfigToValues(seedTrait.config) ?? {}, ...composed);
-  return {
-    count: declaredValue(values, "count", (v) => typeof v === "number"),
-    seed: declaredValue(values, "seed", (v) => typeof v === "number"),
-    defaultPersona: declaredValue(values, "defaultPersona", (v) => typeof v === "string"),
-    restampOnPersona: declaredValue(values, "restampOnPersona", (v) => typeof v === "boolean")
-  };
-}
-function entityByStore(program) {
-  const byStore = /* @__PURE__ */ new Map();
-  for (const entity of program.orbitals.flatMap(orbitalInlineEntities)) {
-    if (entity.collection !== void 0 && entity.collection !== "") byStore.set(entity.collection, entity.name);
-  }
-  return byStore;
-}
-async function readSeededStores(persistence, program) {
-  const stores = {};
-  for (const [store, entityType] of entityByStore(program)) stores[store] = await persistence.list(entityType);
-  return stores;
-}
-
-export { StdMockSeed, declaredSeedConfig, readSeededStores };