@you-agent-factory/factory-replay 0.0.0 → 0.0.2

package/dist/topology.js

@@ -0,0 +1,255 @@
+import { canonicalizeFactoryEvents } from "./replay.js";
+import { projectFactoryTopologyConnection } from "./topology-connection.js";
+import { FACTORY_TOPOLOGY_RELATIONSHIPS } from "./topology-contract.js";
+import { factoryTopologyEntityId, factoryTopologyNodeId, } from "./topology-identity.js";
+export { projectFactoryTopologyConnection } from "./topology-connection.js";
+export { FACTORY_TOPOLOGY_RELATIONSHIPS } from "./topology-contract.js";
+export { factoryTopologyEntityId, factoryTopologyNodeId, } from "./topology-identity.js";
+function handlesFor(kind) {
+    const handles = new Map();
+    for (const relationship of Object.values(FACTORY_TOPOLOGY_RELATIONSHIPS)) {
+        if (relationship.source.nodeKind === kind) {
+            handles.set(relationship.source.handleId, {
+                id: relationship.source.handleId,
+                role: "source",
+            });
+        }
+        if (relationship.target.nodeKind === kind) {
+            handles.set(relationship.target.handleId, {
+                id: relationship.target.handleId,
+                role: "target",
+            });
+        }
+    }
+    return [...handles.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function sortedByIdentity(values) {
+    return [...(values ?? [])].sort((left, right) => {
+        const identityDifference = factoryTopologyEntityId(left.id, left.name).localeCompare(factoryTopologyEntityId(right.id, right.name));
+        return identityDifference || left.name.localeCompare(right.name);
+    });
+}
+function createContext() {
+    return {
+        connections: new Map(),
+        issues: new Map(),
+        nodes: new Map(),
+        resourcesByName: new Map(),
+        workersByName: new Map(),
+        workStatesByName: new Map(),
+        workTypesByName: new Map(),
+    };
+}
+function addNode(context, node) {
+    if (context.nodes.has(node.id)) {
+        const id = `duplicate-entity:${node.id}`;
+        context.issues.set(id, {
+            code: "DUPLICATE_ENTITY_ID",
+            id,
+            message: `Factory topology contains duplicate node id ${node.id}.`,
+            nodeId: node.id,
+        });
+        return;
+    }
+    context.nodes.set(node.id, node);
+}
+function addConnection(context, kind, sourceNodeId, targetNodeId, sourceReference, targetReference) {
+    const result = projectFactoryTopologyConnection([...context.nodes.values()], {
+        kind,
+        sourceNodeId,
+        sourceReference,
+        targetNodeId,
+        targetReference,
+    });
+    if (!result.ok) {
+        context.issues.set(result.issue.id, result.issue);
+        return;
+    }
+    context.connections.set(result.connection.id, result.connection);
+}
+function appendNodes(factory, context) {
+    for (const resource of sortedByIdentity(factory.resources)) {
+        const id = factoryTopologyEntityId(resource.id, resource.name);
+        context.resourcesByName.set(resource.name, id);
+        addNode(context, {
+            capacity: resource.capacity,
+            entityId: id,
+            handles: handlesFor("resource"),
+            id: factoryTopologyNodeId("resource", id),
+            kind: "resource",
+            label: resource.name,
+        });
+    }
+    for (const worker of sortedByIdentity(factory.workers)) {
+        const id = factoryTopologyEntityId(worker.id, worker.name);
+        context.workersByName.set(worker.name, id);
+        addNode(context, {
+            entityId: id,
+            handles: handlesFor("worker"),
+            id: factoryTopologyNodeId("worker", id),
+            kind: "worker",
+            label: worker.name,
+        });
+    }
+    for (const workType of sortedByIdentity(factory.workTypes)) {
+        const id = factoryTopologyEntityId(workType.id, workType.name);
+        context.workTypesByName.set(workType.name, id);
+        addNode(context, {
+            entityId: id,
+            handles: handlesFor("work-type"),
+            id: factoryTopologyNodeId("work-type", id),
+            kind: "work-type",
+            label: workType.name,
+        });
+        const states = new Map();
+        for (const state of sortedByIdentity(workType.states)) {
+            const stateId = `${id}:${factoryTopologyEntityId(state.id, state.name)}`;
+            states.set(state.name, stateId);
+            addNode(context, {
+                category: state.type,
+                entityId: stateId,
+                handles: handlesFor("work-state"),
+                id: factoryTopologyNodeId("work-state", stateId),
+                kind: "work-state",
+                label: state.name,
+                workTypeId: id,
+            });
+        }
+        context.workStatesByName.set(workType.name, states);
+    }
+    for (const workstation of sortedByIdentity(factory.workstations)) {
+        const id = factoryTopologyEntityId(workstation.id, workstation.name);
+        addNode(context, {
+            entityId: id,
+            handles: handlesFor("workstation"),
+            id: factoryTopologyNodeId("workstation", id),
+            kind: "workstation",
+            label: workstation.name,
+        });
+    }
+}
+function appendFoundationConnections(factory, context) {
+    for (const worker of sortedByIdentity(factory.workers)) {
+        const workerEntityId = context.workersByName.get(worker.name);
+        for (const resource of sortedByIdentity(worker.resources)) {
+            const resourceEntityId = context.resourcesByName.get(resource.name);
+            addConnection(context, "worker-resource", resourceEntityId && factoryTopologyNodeId("resource", resourceEntityId), workerEntityId && factoryTopologyNodeId("worker", workerEntityId), resource.name, worker.name);
+        }
+    }
+    for (const workType of sortedByIdentity(factory.workTypes)) {
+        const workTypeEntityId = context.workTypesByName.get(workType.name);
+        for (const state of sortedByIdentity(workType.states)) {
+            const stateEntityId = context.workStatesByName
+                .get(workType.name)
+                ?.get(state.name);
+            addConnection(context, "work-type-state", workTypeEntityId &&
+                factoryTopologyNodeId("work-type", workTypeEntityId), stateEntityId && factoryTopologyNodeId("work-state", stateEntityId), workType.name, `${workType.name}:${state.name}`);
+        }
+    }
+}
+function sortedRoutes(routes) {
+    const normalizedRoutes = !routes
+        ? []
+        : Array.isArray(routes)
+            ? routes
+            : [routes];
+    return [...normalizedRoutes].sort((left, right) => `${left.workType}:${left.state}`.localeCompare(`${right.workType}:${right.state}`));
+}
+function appendRoutes(context, workstation, workstationNodeId) {
+    const routes = [
+        ["workstation-input", workstation.inputs],
+        ["workstation-output", workstation.outputs],
+        ["workstation-on-continue", workstation.onContinue],
+        ["workstation-on-failure", workstation.onFailure],
+        ["workstation-on-rejection", workstation.onRejection],
+        [
+            "workstation-output",
+            workstation.classificationRoutes?.flatMap((route) => route.outputs),
+        ],
+    ];
+    for (const [kind, routeList] of routes) {
+        for (const route of sortedRoutes(routeList)) {
+            const stateEntityId = context.workStatesByName
+                .get(route.workType)
+                ?.get(route.state);
+            if (!stateEntityId &&
+                route.state === "available" &&
+                context.resourcesByName.has(route.workType)) {
+                continue;
+            }
+            const stateNodeId = stateEntityId && factoryTopologyNodeId("work-state", stateEntityId);
+            const isInput = kind === "workstation-input";
+            addConnection(context, kind, isInput ? stateNodeId : workstationNodeId, isInput ? workstationNodeId : stateNodeId, isInput ? `${route.workType}:${route.state}` : workstation.name, isInput ? workstation.name : `${route.workType}:${route.state}`);
+        }
+    }
+}
+function appendWorkstationConnections(factory, context) {
+    for (const workstation of sortedByIdentity(factory.workstations)) {
+        const workstationNodeId = factoryTopologyNodeId("workstation", factoryTopologyEntityId(workstation.id, workstation.name));
+        const workerEntityId = context.workersByName.get(workstation.worker);
+        if (workstation.worker.trim()) {
+            addConnection(context, "worker-assignment", workerEntityId && factoryTopologyNodeId("worker", workerEntityId), workstationNodeId, workstation.worker, workstation.name);
+        }
+        for (const resource of sortedByIdentity(workstation.resources)) {
+            const resourceEntityId = context.resourcesByName.get(resource.name);
+            addConnection(context, "workstation-resource", resourceEntityId && factoryTopologyNodeId("resource", resourceEntityId), workstationNodeId, resource.name, workstation.name);
+        }
+        appendRoutes(context, workstation, workstationNodeId);
+    }
+}
+/** Project one public Factory definition without mutating caller-owned data. */
+export function projectFactoryTopology(input) {
+    if (!input.factory) {
+        return {
+            connections: [],
+            issues: [
+                {
+                    code: "MISSING_FACTORY",
+                    id: "missing-factory",
+                    message: "No Factory topology is available at the selected tick.",
+                },
+            ],
+            nodes: [],
+            ok: false,
+            selectedTick: input.selectedTick,
+        };
+    }
+    const context = createContext();
+    appendNodes(input.factory, context);
+    appendFoundationConnections(input.factory, context);
+    appendWorkstationConnections(input.factory, context);
+    const issues = [...context.issues.values()].sort((left, right) => left.id.localeCompare(right.id));
+    if (issues.length > 0) {
+        return {
+            connections: [],
+            issues,
+            nodes: [],
+            ok: false,
+            selectedTick: input.selectedTick,
+        };
+    }
+    return {
+        connections: [...context.connections.values()].sort((left, right) => left.id.localeCompare(right.id)),
+        issues,
+        nodes: [...context.nodes.values()].sort((left, right) => left.id.localeCompare(right.id)),
+        ok: true,
+        selectedTick: input.selectedTick,
+    };
+}
+/** Reconstruct the last canonical Factory topology effective at one tick. */
+export function projectFactoryTopologyAtTick(input) {
+    let factory;
+    for (const event of canonicalizeFactoryEvents(input.events)) {
+        if (event.context.tick > input.tick)
+            break;
+        if (event.type !== "INITIAL_STRUCTURE_REQUEST" &&
+            event.type !== "FACTORY_CHANGE") {
+            continue;
+        }
+        const payload = event.payload;
+        if (payload.factory && typeof payload.factory === "object") {
+            factory = payload.factory;
+        }
+    }
+    return projectFactoryTopology({ factory, selectedTick: input.tick });
+}

package/package.json

@@ -1,26 +1,51 @@
 {
   "name": "@you-agent-factory/factory-replay",
-  "version": "0.0.0",
-  "description": "Framework-independent deterministic replay primitives for Factory events.",
+  "version": "0.0.2",
+  "description": "Deterministic, framework-independent Factory event replay.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/portpowered/you-agent-factory.git"
+    "url": "git+https://github.com/portpowered/you-agent-factory.git",
+    "directory": "ui/packages/factory-replay"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "type": "module",
   "files": [
-    "README.md",
+    "dist",
     "LICENSE.md",
-    "src"
+    "README.md"
   ],
-  "types": "./src/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./src/index.d.ts",
-      "import": "./src/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run prepare:client && node scripts/build-package.mjs",
+    "check:installed-consumer": "node scripts/verify-installed-consumer.mjs",
+    "check:pack": "node scripts/verify-package-pack.mjs",
+    "check:package-boundary": "node scripts/check-package-boundary.mjs",
+    "prepack": "bun run build",
+    "prepare:client": "bun run --cwd ../client build",
+    "test": "bun run prepare:client && vitest run --config vitest.config.ts",
+    "typecheck": "bun run prepare:client && tsc -p tsconfig.json --noEmit --pretty false",
+    "verify": "bun run typecheck && bun run test && bun run build && bun run check:package-boundary && bun run check:pack && bun run check:installed-consumer"
+  },
+  "peerDependencies": {
+    "@you-agent-factory/client": "0.0.2"
+  },
+  "peerDependenciesMeta": {
+    "@you-agent-factory/client": {
+      "optional": true
     }
   },
-  "dependencies": {
-    "@you-agent-factory/client": "file:../client"
+  "devDependencies": {
+    "typescript": "~5.9.3",
+    "vitest": "4.1.3"
   }
 }

package/src/activity.js

@@ -1,208 +0,0 @@
-/** @param {string | undefined} explicitID @param {string} name */
-function entityID(explicitID, name) {
-  return explicitID?.trim() || name;
-}
-
-/** @param {string} id */
-function workstationNodeID(id) {
-  return `workstation:${id}`;
-}
-
-/** @param {string} id */
-function resourceNodeID(id) {
-  return `resource:${id}`;
-}
-
-/**
- * Project active Dispatch and resource occupancy evidence from one selected
- * canonical replay state without mutating caller-owned data.
- *
- * @param {import("./index.d.ts").FactoryActivityProjectionInput} input
- * @returns {import("./index.d.ts").FactoryActivityProjection}
- */
-export function projectFactoryActivity(input) {
-  const issues = new Map();
-  const { resourcesByName, workstationsByTransition } = indexFactory(
-    input.factory,
-  );
-
-  const occupiedByResource = new Map();
-  const occupancyEvidenceAvailable = input.activeDispatches.every(
-    (dispatch) => dispatch.resourceNames !== undefined,
-  );
-  const activeDispatches = input.activeDispatches.map((evidence) => {
-    const resolved = workstationsByTransition.get(evidence.transitionId);
-    const resourceIds = [];
-    for (const resourceName of evidence.resourceNames ?? []) {
-      const resource = resourcesByName.get(resourceName);
-      if (!resource) {
-        addIssue(
-          issues,
-          "UNRESOLVED_RESOURCE",
-          `dispatch:${evidence.id}:resource:${resourceName}`,
-          `Dispatch ${evidence.id} refers to unknown resource ${resourceName}.`,
-          evidence.id,
-          resourceName,
-        );
-        continue;
-      }
-      resourceIds.push(resource.id);
-      occupiedByResource.set(
-        resource.id,
-        (occupiedByResource.get(resource.id) ?? 0) + 1,
-      );
-    }
-    if (!resolved) {
-      addIssue(
-        issues,
-        "UNRESOLVED_WORKSTATION",
-        `dispatch:${evidence.id}:workstation:${evidence.transitionId}`,
-        `Dispatch ${evidence.id} refers to unknown workstation transition ${evidence.transitionId}.`,
-        evidence.id,
-        evidence.transitionId,
-      );
-    }
-    const workerName = resolved?.workstation.worker?.trim();
-    const worker = workerName
-      ? (input.factory?.workers ?? []).find(
-          (candidate) =>
-            candidate.name === workerName || candidate.id === workerName,
-        )
-      : undefined;
-    if (workerName && !worker) {
-      addIssue(
-        issues,
-        "UNRESOLVED_WORKER",
-        `dispatch:${evidence.id}:worker:${workerName}`,
-        `Dispatch ${evidence.id} refers to unknown worker ${workerName}.`,
-        evidence.id,
-        workerName,
-      );
-    }
-    return {
-      id: evidence.id,
-      resourceIds: [...resourceIds].sort(),
-      startedTick: evidence.startedTick,
-      transitionId: evidence.transitionId,
-      workIds: [...new Set(evidence.workIds)].sort(),
-      ...(resolved
-        ? {
-            workstationId: resolved.id,
-            workstationNodeId: workstationNodeID(resolved.id),
-          }
-        : {}),
-      ...(worker
-        ? { workerId: entityID(worker.id, worker.name) }
-        : {}),
-    };
-  });
-
-  const resourceOccupancy = projectResourceOccupancy(
-    resourcesByName,
-    occupiedByResource,
-    occupancyEvidenceAvailable,
-    issues,
-  );
-
-  return {
-    activeDispatches: activeDispatches.sort((left, right) =>
-      left.id.localeCompare(right.id),
-    ),
-    activeWorkstationIds: [
-      ...new Set(
-        activeDispatches.flatMap((dispatch) =>
-          dispatch.workstationId ? [dispatch.workstationId] : [],
-        ),
-      ),
-    ].sort(),
-    issues: [...issues.values()].sort((left, right) =>
-      left.id.localeCompare(right.id),
-    ),
-    resourceOccupancy: resourceOccupancy.sort((left, right) =>
-      left.resourceId.localeCompare(right.resourceId),
-    ),
-    selectedTick: input.selectedTick,
-  };
-}
-
-/** @param {import("@you-agent-factory/client").FactoryDefinition | undefined} factory */
-function indexFactory(factory) {
-  const resourcesByName = new Map();
-  const workstationsByTransition = new Map();
-  for (const resource of factory?.resources ?? []) {
-    resourcesByName.set(resource.name, {
-      capacity: Math.max(0, resource.capacity),
-      id: entityID(resource.id, resource.name),
-    });
-  }
-  for (const workstation of factory?.workstations ?? []) {
-    const id = entityID(workstation.id, workstation.name);
-    workstationsByTransition.set(workstation.name, { id, workstation });
-    if (workstation.id?.trim()) {
-      workstationsByTransition.set(workstation.id, { id, workstation });
-    }
-  }
-  return { resourcesByName, workstationsByTransition };
-}
-
-/**
- * @param {Map<string, {capacity: number, id: string}>} resourcesByName
- * @param {Map<string, number>} occupiedByResource
- * @param {boolean} evidenceAvailable
- * @param {Map<string, import("./index.d.ts").FactoryActivityProjectionIssue>} issues
- * @returns {import("./index.d.ts").FactoryResourceOccupancyProjection[]}
- */
-function projectResourceOccupancy(
-  resourcesByName,
-  occupiedByResource,
-  evidenceAvailable,
-  issues,
-) {
-  return [...resourcesByName.values()].map((resource) => {
-    if (!evidenceAvailable) {
-      return {
-        capacity: resource.capacity,
-        evidence: "unavailable",
-        resourceId: resource.id,
-        resourceNodeId: resourceNodeID(resource.id),
-      };
-    }
-    const occupiedQuantity = occupiedByResource.get(resource.id) ?? 0;
-    if (occupiedQuantity > resource.capacity) {
-      addIssue(
-        issues,
-        "RESOURCE_CAPACITY_EXCEEDED",
-        `resource:${resource.id}:capacity-exceeded`,
-        `Resource ${resource.id} has ${occupiedQuantity} occupied units for capacity ${resource.capacity}.`,
-        undefined,
-        resource.id,
-      );
-    }
-    return {
-      availableQuantity: Math.max(0, resource.capacity - occupiedQuantity),
-      capacity: resource.capacity,
-      evidence: "known",
-      occupiedQuantity,
-      resourceId: resource.id,
-      resourceNodeId: resourceNodeID(resource.id),
-    };
-  });
-}
-
-/**
- * @param {Map<string, import("./index.d.ts").FactoryActivityProjectionIssue>} issues
- * @param {import("./index.d.ts").FactoryActivityProjectionIssue["code"]} code
- * @param {string} id
- * @param {string} message
- * @param {string | undefined} dispatchId
- * @param {string | undefined} reference
- */
-function addIssue(issues, code, id, message, dispatchId, reference) {
-  issues.set(id, {
-    code,
-    id,
-    message,
-    ...(dispatchId ? { dispatchId } : {}),
-    ...(reference ? { reference } : {}),
-  });
-}