@you-agent-factory/factory-emulator 0.0.0 → 0.0.1

package/dist/submission-replay.d.ts

@@ -0,0 +1,14 @@
+import type { FactoryEvent } from "@you-agent-factory/client";
+import type { FactoryEmulatorNormalizedRelation } from "./session-contracts.js";
+export interface FactoryEmulatorReplayedWork {
+    readonly submissionId: string;
+    readonly workId: string;
+    readonly requestId?: string;
+    readonly traceId?: string;
+    readonly workType?: string;
+    readonly state?: string;
+    readonly input?: unknown;
+    readonly relations?: readonly FactoryEmulatorNormalizedRelation[];
+}
+/** Reapply canonical submission events into detached Work and relationship state. */
+export declare function replayFactoryEmulatorSubmissions(events: readonly FactoryEvent[]): readonly FactoryEmulatorReplayedWork[];

package/dist/submission-replay.js

@@ -0,0 +1,96 @@
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function normalizedRelation(value, worksByName) {
+    const relation = record(value);
+    if (relation?.type !== "DEPENDS_ON" ||
+        typeof relation.sourceWorkName !== "string" ||
+        typeof relation.targetWorkName !== "string") {
+        return undefined;
+    }
+    const targetWorkId = typeof relation.targetWorkId === "string"
+        ? relation.targetWorkId
+        : worksByName.get(relation.targetWorkName)?.workId;
+    if (targetWorkId === undefined)
+        return undefined;
+    return {
+        type: "DEPENDS_ON",
+        sourceWorkName: relation.sourceWorkName,
+        targetWorkName: relation.targetWorkName,
+        targetWorkId,
+        requiredState: typeof relation.requiredState === "string"
+            ? relation.requiredState
+            : "complete",
+    };
+}
+function applyRelation(value, worksByName) {
+    const relation = normalizedRelation(value, worksByName);
+    if (relation === undefined)
+        return;
+    const source = worksByName.get(relation.sourceWorkName);
+    if (source === undefined)
+        return;
+    const key = (candidate) => `${candidate.type}\u0000${candidate.sourceWorkName}\u0000${candidate.targetWorkId}\u0000${candidate.requiredState}`;
+    const existing = source.relations.findIndex((candidate) => key(candidate) === key(relation));
+    if (existing === -1)
+        source.relations.push(relation);
+    else
+        source.relations[existing] = relation;
+}
+/** Reapply canonical submission events into detached Work and relationship state. */
+export function replayFactoryEmulatorSubmissions(events) {
+    const works = [];
+    const worksByName = new Map();
+    for (const event of events) {
+        const payload = record(event.payload);
+        if (event.type === "WORK_REQUEST") {
+            const eventWorks = Array.isArray(payload?.works) ? payload.works : [];
+            for (const [index, value] of eventWorks.entries()) {
+                const work = record(value);
+                if (typeof work?.name !== "string" || typeof work.workId !== "string") {
+                    continue;
+                }
+                const state = record(work.state);
+                const replayed = {
+                    submissionId: work.name,
+                    workId: work.workId,
+                    ...(typeof work.requestId === "string"
+                        ? { requestId: work.requestId }
+                        : event.context.requestId
+                            ? { requestId: event.context.requestId }
+                            : {}),
+                    ...(typeof work.traceId === "string"
+                        ? { traceId: work.traceId }
+                        : event.context.traceIds?.[index]
+                            ? { traceId: event.context.traceIds[index] }
+                            : {}),
+                    ...(typeof work.workTypeName === "string"
+                        ? { workType: work.workTypeName }
+                        : {}),
+                    ...(typeof state?.name === "string" ? { state: state.name } : {}),
+                    ...("payload" in work ? { input: work.payload } : {}),
+                    relations: [],
+                };
+                works.push(replayed);
+                worksByName.set(replayed.submissionId, replayed);
+            }
+            for (const relation of Array.isArray(payload?.relations)
+                ? payload.relations
+                : []) {
+                applyRelation(relation, worksByName);
+            }
+            continue;
+        }
+        if (event.type === "RELATIONSHIP_CHANGE_REQUEST") {
+            applyRelation(record(payload?.relation), worksByName);
+        }
+    }
+    return works.map(({ relations, ...work }) => ({
+        ...work,
+        ...(relations.length === 0
+            ? {}
+            : { relations: relations.map((relation) => ({ ...relation })) }),
+    }));
+}

package/dist/submission-validation.d.ts

@@ -0,0 +1,3 @@
+import type { FactoryDefinition } from "@you-agent-factory/client";
+import type { FactoryEmulatorScenarioIssue, FactoryEmulatorSubmissionBatch } from "./scenario-contracts.js";
+export declare function validateDependencyRelationships(initial: FactoryEmulatorSubmissionBatch, factory: FactoryDefinition, issues: FactoryEmulatorScenarioIssue[]): void;

package/dist/submission-validation.js

@@ -0,0 +1,113 @@
+export function validateDependencyRelationships(initial, factory, issues) {
+    const relations = initial.relations ?? [];
+    const workByName = new Map(initial.works.map((work) => [work.name, work]));
+    const targetsBySource = new Map();
+    const relationKeys = new Map();
+    for (const [index, relation] of relations.entries()) {
+        const path = ["initialSubmissions", "relations", index];
+        if (relation.type !== "DEPENDS_ON") {
+            issues.push({
+                category: "semantic",
+                code: "invalid_initial_submission_relationship",
+                path: [...path, "type"],
+                message: `Relationship type ${relation.type} is unsupported; the emulator accepts only DEPENDS_ON.`,
+            });
+        }
+        const source = workByName.get(relation.sourceWorkName);
+        const target = workByName.get(relation.targetWorkName);
+        validateEndpoints(relation, source, target, path, issues);
+        validateRequiredState(relation, target, factory, path, issues);
+        const key = `${relation.type}\u0000${relation.sourceWorkName}\u0000${relation.targetWorkName}`;
+        const indexes = relationKeys.get(key) ?? [];
+        indexes.push(index);
+        relationKeys.set(key, indexes);
+        if (relation.type === "DEPENDS_ON" &&
+            source !== undefined &&
+            target !== undefined &&
+            source !== target) {
+            const targets = targetsBySource.get(source.name) ?? [];
+            targets.push(target.name);
+            targetsBySource.set(source.name, targets);
+        }
+    }
+    addDuplicateRelationIssues(relationKeys, issues);
+    addCycleIssues(relations, targetsBySource, issues);
+}
+function validateEndpoints(relation, source, target, path, issues) {
+    if (source === undefined) {
+        issues.push({
+            category: "semantic",
+            code: "invalid_initial_submission_relationship",
+            path: [...path, "sourceWorkName"],
+            message: `Source Work ${relation.sourceWorkName} is not in this submission batch.`,
+        });
+    }
+    if (target === undefined) {
+        issues.push({
+            category: "semantic",
+            code: "invalid_initial_submission_relationship",
+            path: [...path, "targetWorkName"],
+            message: `Target Work ${relation.targetWorkName} is not in this submission batch.`,
+        });
+    }
+    if (relation.sourceWorkName === relation.targetWorkName) {
+        issues.push({
+            category: "semantic",
+            code: "invalid_initial_submission_relationship",
+            path,
+            message: "A Work item cannot depend on itself.",
+        });
+    }
+}
+function validateRequiredState(relation, target, factory, path, issues) {
+    if (target === undefined)
+        return;
+    const requiredState = relation.requiredState ?? "complete";
+    const targetStates = factory.workTypes
+        ?.find(({ name }) => name === target.workType)
+        ?.states.map(({ name }) => name);
+    if (!targetStates?.includes(requiredState)) {
+        issues.push({
+            category: "semantic",
+            code: "invalid_initial_submission_relationship",
+            path: [...path, "requiredState"],
+            message: `Required state ${requiredState} is not declared by target Work type ${target.workType}.`,
+        });
+    }
+}
+function addDuplicateRelationIssues(relationKeys, issues) {
+    for (const indexes of relationKeys.values()) {
+        if (indexes.length < 2)
+            continue;
+        for (const index of indexes) {
+            issues.push({
+                category: "semantic",
+                code: "duplicate_identity",
+                path: ["initialSubmissions", "relations", index],
+                message: `Submission relationship is duplicated at indexes ${indexes.join(", ")}.`,
+            });
+        }
+    }
+}
+function addCycleIssues(relations, targetsBySource, issues) {
+    const reaches = (current, goal, visited) => {
+        if (current === goal)
+            return true;
+        if (visited.has(current))
+            return false;
+        visited.add(current);
+        return (targetsBySource.get(current) ?? []).some((target) => reaches(target, goal, visited));
+    };
+    relations.forEach((relation, index) => {
+        if (relation.type === "DEPENDS_ON" &&
+            relation.sourceWorkName !== relation.targetWorkName &&
+            reaches(relation.targetWorkName, relation.sourceWorkName, new Set())) {
+            issues.push({
+                category: "semantic",
+                code: "invalid_initial_submission_relationship",
+                path: ["initialSubmissions", "relations", index],
+                message: "DEPENDS_ON relationships must be acyclic.",
+            });
+        }
+    });
+}

package/examples/customer-support.scenario.v1.json

@@ -0,0 +1,45 @@
+{
+  "schemaVersion": "factory-emulator-scenario/v1",
+  "id": "customer-support-happy-path",
+  "factory": {
+    "name": "customer-support"
+  },
+  "seed": "customer-support-seed-001",
+  "startAt": "2026-07-18T16:00:00.000Z",
+  "rules": [
+    {
+      "id": "triage-new-ticket",
+      "selector": {
+        "workstation": "triage",
+        "worker": "support-agent",
+        "input": {
+          "workType": "ticket",
+          "state": "new"
+        }
+      },
+      "cursor": {
+        "scope": "lineage",
+        "input": "rootWorkId"
+      },
+      "outcomes": [
+        {
+          "result": "accepted",
+          "durationMs": 25,
+          "output": "Ticket classified"
+        }
+      ],
+      "exhaustion": "repeat-last"
+    }
+  ],
+  "unmatched": {
+    "behavior": "error"
+  },
+  "initialSubmissions": [
+    {
+      "name": "ticket-001",
+      "workType": "ticket",
+      "state": "new",
+      "input": "Customer cannot sign in"
+    }
+  ]
+}

package/package.json

@@ -1,44 +1,66 @@
 {
   "name": "@you-agent-factory/factory-emulator",
-  "version": "0.0.0",
-  "description": "Deterministic scenario and event sink contracts for Factory emulator hosts.",
+  "version": "0.0.1",
+  "description": "Deterministic Factory emulator contracts and caller-owned event sinks.",
   "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-emulator"
+  },
+  "publishConfig": {
+    "access": "public"
   },
-  "type": "module",
   "files": [
-    "README.md",
+    "dist",
+    "examples",
+    "schema",
     "LICENSE.md",
-    "generated",
-    "src"
+    "README.md"
   ],
-  "types": "./src/index.ts",
+  "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
-    "./schema": "./generated/factory-emulator-scenario.schema.json",
-    "./generated/types": {
-      "types": "./src/generated/scenario.ts"
-    }
+    "./schema": "./schema/scenario.schema.json",
+    "./examples/customer-support.scenario.v1.json": "./examples/customer-support.scenario.v1.json"
   },
-  "peerDependencies": {
-    "@you-agent-factory/client": "*"
+  "scripts": {
+    "build": "node scripts/build-package.mjs",
+    "check:changed-paths": "node scripts/check-changed-paths.mjs",
+    "check:generated": "node scripts/generate-scenario-schema.mjs --check",
+    "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",
+    "check:runtime-reference-conformance": "node scripts/check-runtime-reference-conformance.mjs",
+    "generate": "node scripts/generate-scenario-schema.mjs",
+    "lint": "biome check src scripts vitest.config.ts",
+    "prepack": "bun run build",
+    "test": "vitest run --config vitest.config.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit --pretty false",
+    "verify": "bun run verify:release && bun run check:changed-paths",
+    "verify:release": "bun run check:generated && bun run typecheck && bun run lint && bun run test && bun run build && bun run check:runtime-reference-conformance && bun run check:package-boundary && bun run check:pack && bun run check:installed-consumer"
   },
   "dependencies": {
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1"
   },
+  "peerDependencies": {
+    "@you-agent-factory/client": "0.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@you-agent-factory/client": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@biomejs/biome": "^2.5.4",
     "@you-agent-factory/client": "file:../client",
-    "typescript": "~5.9.3"
-  },
-  "scripts": {
-    "generate": "node ../../scripts/generate-emulator.mjs",
-    "test": "node --test --test-concurrency=1 test/*.test.mjs",
-    "typecheck": "tsc --project tsconfig.json"
+    "typescript": "~5.9.3",
+    "vitest": "4.1.3"
   }
 }

package/schema/scenario.schema.json

@@ -0,0 +1,171 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://you-agent-factory.dev/schemas/ui/factory-emulator/scenario/v1",
+  "title": "Factory Emulator Scenario v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "id",
+    "factory",
+    "seed",
+    "startAt",
+    "rules",
+    "unmatched"
+  ],
+  "properties": {
+    "schemaVersion": { "const": "factory-emulator-scenario/v1" },
+    "id": { "$ref": "#/$defs/stableIdentity" },
+    "factory": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["name"],
+      "properties": { "name": { "$ref": "#/$defs/nonEmptyText128" } }
+    },
+    "seed": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "startAt": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]{3}Z$"
+    },
+    "rules": {
+      "type": "array",
+      "items": { "$ref": "#/$defs/rule" }
+    },
+    "unmatched": { "$ref": "#/$defs/unmatched" },
+    "initialSubmissions": {
+      "oneOf": [
+        {
+          "type": "array",
+          "items": { "$ref": "#/$defs/initialSubmission" }
+        },
+        { "$ref": "#/$defs/submissionBatch" }
+      ]
+    }
+  },
+  "$defs": {
+    "stableIdentity": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 128,
+      "pattern": "^[A-Za-z0-9][A-Za-z0-9._-]*$"
+    },
+    "nonEmptyText128": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "plainText": { "type": "string", "maxLength": 65536 },
+    "feedbackText": { "type": "string", "maxLength": 4096 },
+    "activityLabel": { "type": "string", "minLength": 1, "maxLength": 120 },
+    "inputSelector": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "workType": { "$ref": "#/$defs/nonEmptyText128" },
+        "state": { "$ref": "#/$defs/nonEmptyText128" },
+        "name": { "$ref": "#/$defs/nonEmptyText128" }
+      }
+    },
+    "selector": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "workstation": { "$ref": "#/$defs/nonEmptyText128" },
+        "worker": { "$ref": "#/$defs/nonEmptyText128" },
+        "input": { "$ref": "#/$defs/inputSelector" }
+      }
+    },
+    "cursor": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["scope", "input"],
+      "properties": {
+        "scope": { "const": "lineage" },
+        "input": { "const": "rootWorkId" }
+      }
+    },
+    "outcome": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["result", "durationMs"],
+      "properties": {
+        "result": { "enum": ["accepted", "continued", "rejected", "failed"] },
+        "durationMs": { "type": "number", "minimum": 0 },
+        "output": { "$ref": "#/$defs/plainText" },
+        "feedback": { "$ref": "#/$defs/feedbackText" },
+        "activityLabel": { "$ref": "#/$defs/activityLabel" },
+        "error": { "$ref": "#/$defs/feedbackText" }
+      }
+    },
+    "rule": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "selector", "cursor", "outcomes", "exhaustion"],
+      "properties": {
+        "id": { "$ref": "#/$defs/stableIdentity" },
+        "selector": { "$ref": "#/$defs/selector" },
+        "cursor": { "$ref": "#/$defs/cursor" },
+        "outcomes": {
+          "type": "array",
+          "minItems": 1,
+          "items": { "$ref": "#/$defs/outcome" }
+        },
+        "exhaustion": { "enum": ["repeat-last", "fail"] }
+      }
+    },
+    "unmatched": {
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["behavior"],
+          "properties": { "behavior": { "const": "error" } }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["behavior", "outcome"],
+          "properties": {
+            "behavior": { "const": "outcome" },
+            "outcome": { "$ref": "#/$defs/outcome" }
+          }
+        }
+      ]
+    },
+    "initialSubmission": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["name", "workType", "state"],
+      "properties": {
+        "name": { "$ref": "#/$defs/stableIdentity" },
+        "workType": { "$ref": "#/$defs/nonEmptyText128" },
+        "state": { "$ref": "#/$defs/nonEmptyText128" },
+        "input": { "$ref": "#/$defs/plainText" },
+        "parent": { "$ref": "#/$defs/stableIdentity" }
+      }
+    },
+    "submissionRelation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["type", "sourceWorkName", "targetWorkName"],
+      "properties": {
+        "type": { "enum": ["DEPENDS_ON", "PARENT_CHILD", "SPAWNED_BY"] },
+        "sourceWorkName": { "$ref": "#/$defs/stableIdentity" },
+        "targetWorkName": { "$ref": "#/$defs/stableIdentity" },
+        "requiredState": { "$ref": "#/$defs/nonEmptyText128" }
+      }
+    },
+    "submissionBatch": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["works"],
+      "properties": {
+        "works": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/initialSubmission" }
+        },
+        "relations": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/submissionRelation" }
+        }
+      }
+    }
+  }
+}