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

package/dist/activity.js

@@ -0,0 +1,306 @@
+import { projectFactoryLoad } from "./load.js";
+import { projectFactoryTopology } from "./topology.js";
+import { factoryTopologyEntityId, factoryTopologyNodeId, } from "./topology-identity.js";
+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);
+    });
+}
+/** Build the stable public identity of one active Dispatch overlay. */
+export function factoryDispatchOverlayId(dispatchId) {
+    return `dispatch:${dispatchId}`;
+}
+/** Build the stable public identity used when an overlay references Work. */
+export function factoryWorkProjectionId(workId) {
+    return `work:${workId}`;
+}
+/** Project selected-tick active Dispatch overlays and their topology activity. */
+export function projectFactoryActivity(input) {
+    const issues = new Map();
+    const index = indexFactory(input.factory, input.selectedTick);
+    const dispatches = normalizeDispatches(input.activeDispatches, issues);
+    const activeDispatchOverlays = dispatches.map((dispatch) => projectOverlay(dispatch, index, issues));
+    const load = projectFactoryLoad({
+        activeDispatches: dispatches.map((dispatch) => ({
+            id: dispatch.id,
+            ...(dispatch.resourceNames
+                ? {
+                    resourceClaims: dispatch.resourceNames.map((resourceName) => ({
+                        resourceName,
+                    })),
+                }
+                : {}),
+        })),
+        factory: input.factory,
+        selectedTick: input.selectedTick,
+        works: [],
+    });
+    appendLoadIssues(load.issues, issues);
+    return {
+        activeDispatchOverlays: activeDispatchOverlays.sort((left, right) => left.id.localeCompare(right.id)),
+        activeWorkstationNodeIds: [
+            ...new Set(activeDispatchOverlays.flatMap((overlay) => overlay.workstationNodeId ? [overlay.workstationNodeId] : [])),
+        ].sort(),
+        issues: [...issues.values()].sort((left, right) => left.id.localeCompare(right.id)),
+        resourceOccupancy: load.resourceOccupancy,
+        selectedTick: input.selectedTick,
+    };
+}
+function indexFactory(factory, selectedTick) {
+    const topology = projectFactoryTopology({ factory, selectedTick });
+    const resourcesByName = new Map();
+    const workersByName = new Map();
+    const workstationsByTransition = new Map();
+    const workStates = new Map();
+    for (const resource of sortedByIdentity(factory?.resources)) {
+        const id = factoryTopologyEntityId(resource.id, resource.name);
+        resourcesByName.set(resource.name, {
+            id,
+            nodeId: factoryTopologyNodeId("resource", id),
+        });
+    }
+    for (const worker of sortedByIdentity(factory?.workers)) {
+        const id = factoryTopologyEntityId(worker.id, worker.name);
+        const value = { id, nodeId: factoryTopologyNodeId("worker", id) };
+        workersByName.set(worker.name, value);
+        workersByName.set(id, value);
+    }
+    for (const workType of sortedByIdentity(factory?.workTypes)) {
+        const workTypeId = factoryTopologyEntityId(workType.id, workType.name);
+        for (const state of sortedByIdentity(workType.states)) {
+            const stateId = `${workTypeId}:${factoryTopologyEntityId(state.id, state.name)}`;
+            const nodeId = factoryTopologyNodeId("work-state", stateId);
+            for (const typeReference of [workType.name, workTypeId]) {
+                for (const stateReference of [state.name, state.id?.trim()]) {
+                    if (stateReference) {
+                        workStates.set(`${typeReference}\u0000${stateReference}`, nodeId);
+                    }
+                }
+            }
+        }
+    }
+    for (const workstation of sortedByIdentity(factory?.workstations)) {
+        const id = factoryTopologyEntityId(workstation.id, workstation.name);
+        const value = {
+            id,
+            nodeId: factoryTopologyNodeId("workstation", id),
+            workstation,
+        };
+        workstationsByTransition.set(workstation.name, value);
+        workstationsByTransition.set(id, value);
+    }
+    return {
+        resourcesByName,
+        topology,
+        workersByName,
+        workstationsByTransition,
+        workStates,
+    };
+}
+function projectOverlay(dispatch, index, issues) {
+    const resolved = dispatch.transitionId
+        ? index.workstationsByTransition.get(dispatch.transitionId)
+        : undefined;
+    if (!resolved && dispatch.transitionId) {
+        addIssue(issues, {
+            code: "UNRESOLVED_WORKSTATION",
+            dispatchId: dispatch.id,
+            id: `dispatch:${dispatch.id}:workstation:${dispatch.transitionId}`,
+            message: `Dispatch ${dispatch.id} refers to unknown workstation transition ${dispatch.transitionId}.`,
+            reference: dispatch.transitionId,
+        });
+    }
+    const workerName = resolved?.workstation.worker?.trim();
+    const worker = workerName ? index.workersByName.get(workerName) : undefined;
+    if (workerName && !worker) {
+        addIssue(issues, {
+            code: "UNRESOLVED_WORKER",
+            dispatchId: dispatch.id,
+            id: `dispatch:${dispatch.id}:worker:${workerName}`,
+            message: `Dispatch ${dispatch.id} refers to unknown worker ${workerName}.`,
+            reference: workerName,
+        });
+    }
+    const resources = resolveResources(dispatch, index, issues);
+    const routeNodeIds = resolveRouteNodeIds(dispatch, index, issues);
+    const connectionIds = resolveConnections(dispatch, index.topology, resolved?.nodeId, worker?.nodeId, resources?.map((resource) => resource.nodeId), routeNodeIds, issues);
+    const workIds = dispatch.workIds
+        ? [...new Set(dispatch.workIds)].sort()
+        : undefined;
+    return {
+        connectionIds,
+        dispatchId: dispatch.id,
+        evidence: {
+            resources: dispatch.resourceNames ? "known" : "unavailable",
+            route: dispatch.inputRoutes ? "known" : "unavailable",
+            work: dispatch.workIds ? "known" : "unavailable",
+            worker: worker ? "known" : "unavailable",
+            workstation: resolved ? "known" : "unavailable",
+        },
+        id: factoryDispatchOverlayId(dispatch.id),
+        ...(resources
+            ? {
+                resourceIds: resources.map((resource) => resource.id).sort(),
+                resourceNodeIds: resources.map((resource) => resource.nodeId).sort(),
+            }
+            : {}),
+        startedTick: dispatch.startedTick,
+        ...(dispatch.transitionId ? { transitionId: dispatch.transitionId } : {}),
+        ...(worker ? { workerId: worker.id, workerNodeId: worker.nodeId } : {}),
+        ...(workIds
+            ? {
+                workIds,
+                workProjectionIds: workIds.map(factoryWorkProjectionId),
+            }
+            : {}),
+        ...(resolved
+            ? {
+                workstationId: resolved.id,
+                workstationNodeId: resolved.nodeId,
+            }
+            : {}),
+    };
+}
+function resolveResources(dispatch, index, issues) {
+    if (!dispatch.resourceNames)
+        return undefined;
+    const resources = new Map();
+    for (const resourceName of dispatch.resourceNames) {
+        const resource = index.resourcesByName.get(resourceName);
+        if (resource) {
+            resources.set(resource.id, resource);
+            continue;
+        }
+        addIssue(issues, {
+            code: "UNRESOLVED_RESOURCE",
+            dispatchId: dispatch.id,
+            id: `dispatch:${dispatch.id}:resource:${resourceName}`,
+            message: `Dispatch ${dispatch.id} refers to unknown resource ${resourceName}.`,
+            reference: resourceName,
+        });
+    }
+    return [...resources.values()];
+}
+function resolveRouteNodeIds(dispatch, index, issues) {
+    if (!dispatch.inputRoutes)
+        return undefined;
+    const nodeIds = new Set();
+    for (const route of dispatch.inputRoutes) {
+        const nodeId = resolveRouteNodeId(route, index);
+        if (nodeId) {
+            nodeIds.add(nodeId);
+            continue;
+        }
+        const reference = `${route.workTypeId ?? "?"}:${route.stateId ?? route.stateName ?? "?"}`;
+        addIssue(issues, {
+            code: "UNRESOLVED_ROUTE",
+            dispatchId: dispatch.id,
+            id: `dispatch:${dispatch.id}:route:${reference}`,
+            message: `Dispatch ${dispatch.id} input route ${reference} is not present in the selected topology.`,
+            reference,
+        });
+    }
+    return [...nodeIds].sort();
+}
+function resolveRouteNodeId(route, index) {
+    if (!route.workTypeId)
+        return undefined;
+    for (const stateReference of [route.stateId, route.stateName]) {
+        if (!stateReference)
+            continue;
+        const nodeId = index.workStates.get(`${route.workTypeId}\u0000${stateReference}`);
+        if (nodeId)
+            return nodeId;
+    }
+    return undefined;
+}
+function resolveConnections(dispatch, topology, workstationNodeId, workerNodeId, resourceNodeIds, routeNodeIds, issues) {
+    if (!workstationNodeId)
+        return [];
+    if (!topology.ok) {
+        addIssue(issues, {
+            code: "UNAVAILABLE_TOPOLOGY_PATH",
+            dispatchId: dispatch.id,
+            id: `dispatch:${dispatch.id}:topology-path-unavailable`,
+            message: `Dispatch ${dispatch.id} topology paths are unavailable because the selected topology is invalid.`,
+        });
+        return [];
+    }
+    const resourceSet = resourceNodeIds && new Set(resourceNodeIds);
+    const routeSet = routeNodeIds && new Set(routeNodeIds);
+    return topology.connections
+        .filter((connection) => isRelevantConnection(connection, workstationNodeId, workerNodeId, resourceSet, routeSet))
+        .map((connection) => connection.id)
+        .sort();
+}
+function isRelevantConnection(connection, workstationNodeId, workerNodeId, resourceNodeIds, routeNodeIds) {
+    if (connection.kind === "worker-assignment" &&
+        workerNodeId &&
+        connection.source.nodeId === workerNodeId &&
+        connection.target.nodeId === workstationNodeId) {
+        return true;
+    }
+    if (connection.kind === "workstation-resource" &&
+        resourceNodeIds?.has(connection.source.nodeId) &&
+        connection.target.nodeId === workstationNodeId) {
+        return true;
+    }
+    return Boolean(connection.kind === "workstation-input" &&
+        routeNodeIds?.has(connection.source.nodeId) &&
+        connection.target.nodeId === workstationNodeId);
+}
+function normalizeDispatches(dispatches, issues) {
+    const grouped = new Map();
+    for (const dispatch of dispatches) {
+        const values = grouped.get(dispatch.id) ?? [];
+        values.push(dispatch);
+        grouped.set(dispatch.id, values);
+    }
+    const normalized = [];
+    for (const [dispatchId, values] of grouped) {
+        const keyed = new Map(values.map((value) => [evidenceKey(value), value]));
+        if (keyed.size > 1) {
+            addIssue(issues, {
+                code: "CONTRADICTORY_DISPATCH_EVIDENCE",
+                dispatchId,
+                id: `dispatch:${dispatchId}:contradictory-evidence`,
+                message: `Dispatch ${dispatchId} has contradictory selected-tick activity evidence.`,
+            });
+        }
+        normalized.push([...keyed.values()].sort((left, right) => evidenceKey(left).localeCompare(evidenceKey(right)))[0]);
+    }
+    return normalized.sort((left, right) => left.id.localeCompare(right.id));
+}
+function evidenceKey(dispatch) {
+    const sorted = (values) => values ? [...values].sort().join("\u0000") : "?";
+    return [
+        dispatch.startedTick,
+        dispatch.transitionId ?? "?",
+        sorted(dispatch.workIds),
+        sorted(dispatch.resourceNames),
+        dispatch.inputRoutes
+            ? dispatch.inputRoutes
+                .map((route) => `${route.workTypeId ?? "?"}\u0000${route.stateId ?? "?"}\u0000${route.stateName ?? "?"}`)
+                .sort()
+                .join("\u0002")
+            : "?",
+    ].join("\u0001");
+}
+function appendLoadIssues(loadIssues, issues) {
+    for (const issue of loadIssues) {
+        const code = issue.code === "UNRESOLVED_RESOURCE_CLAIM"
+            ? "UNRESOLVED_RESOURCE"
+            : issue.code;
+        if (code !== "INVALID_RESOURCE_CAPACITY" &&
+            code !== "MISSING_FACTORY" &&
+            code !== "RESOURCE_CAPACITY_EXCEEDED" &&
+            code !== "UNRESOLVED_RESOURCE") {
+            continue;
+        }
+        addIssue(issues, { ...issue, code });
+    }
+}
+function addIssue(issues, issue) {
+    issues.set(issue.id, issue);
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { factoryDispatchOverlayId, factoryWorkProjectionId, projectFactoryActivity, } from "./activity.js";
+export type { FactoryActiveDispatchEvidence, FactoryActivityAtTickInput, FactoryActivityProjection, FactoryActivityProjectionInput, FactoryActivityProjectionIssue, FactoryDispatchOverlayEvidenceStatus, FactoryDispatchOverlayProjection, FactoryDispatchRouteEvidence, } from "./activity-contract.js";
+export { projectFactoryActivityAtTick } from "./activity-replay.js";
+export { projectFactoryLoad } from "./load.js";
+export type { FactoryActiveResourceClaimsEvidence, FactoryLoadAtTickInput, FactoryLoadProjection, FactoryLoadProjectionInput, FactoryLoadProjectionIssue, FactoryResourceClaimEvidence, FactoryResourceOccupancyProjection, FactoryWorkStateCountProjection, FactoryWorkStateOccupancyEvidence, } from "./load-contract.js";
+export { projectFactoryLoadAtTick } from "./load-replay.js";
+export { type FactoryWorkProgressAtTickInput, type FactoryWorkProgressCategory, type FactoryWorkProgressCounts, type FactoryWorkProgressEvidence, type FactoryWorkProgressItem, type FactoryWorkProgressProjection, type FactoryWorkProgressProjectionInput, type FactoryWorkProgressStateEvidence, type FactoryWorkStateCategory, projectFactoryWorkProgress, projectFactoryWorkProgressAtTick, } from "./progress.js";
+export { advanceFactoryReplay, advanceFactoryReplayCheckpoint, canonicalizeFactoryEvents, createFactoryReplayWorldCheckpoint, type FactoryReplayCheckpoint, type FactoryReplayCheckpointAdvancement, type FactoryReplayFixedSelection, type FactoryReplayInitialization, type FactoryReplayReducer, type FactoryReplayResult, type FactoryReplaySelection, type FactoryReplayStateCloner, type FactoryReplayWorldAdvanceInput, type FactoryReplayWorldAdvanceResult, type FactoryReplayWorldCheckpoint, type FactoryReplayWorldReducer, type FactoryReplayWorldResult, initializeFactoryReplay, projectFactoryStateAtTick, projectFactoryWorldAtTick, } from "./replay.js";
+export { FACTORY_TOPOLOGY_RELATIONSHIPS, type FactoryResourceTopologyNode, type FactoryTopologyAtTickInput, type FactoryTopologyConnection, type FactoryTopologyConnectionCandidate, type FactoryTopologyConnectionEndpoint, type FactoryTopologyConnectionKind, type FactoryTopologyConnectionResult, type FactoryTopologyHandle, type FactoryTopologyHandleId, type FactoryTopologyNode, type FactoryTopologyNodeKind, type FactoryTopologyProjection, type FactoryTopologyProjectionInput, type FactoryTopologyProjectionIssue, type FactoryWorkerTopologyNode, type FactoryWorkStateTopologyNode, type FactoryWorkstationTopologyNode, type FactoryWorkTypeTopologyNode, factoryTopologyEntityId, factoryTopologyNodeId, projectFactoryTopology, projectFactoryTopologyAtTick, projectFactoryTopologyConnection, } from "./topology.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { factoryDispatchOverlayId, factoryWorkProjectionId, projectFactoryActivity, } from "./activity.js";
+export { projectFactoryActivityAtTick } from "./activity-replay.js";
+export { projectFactoryLoad } from "./load.js";
+export { projectFactoryLoadAtTick } from "./load-replay.js";
+export { projectFactoryWorkProgress, projectFactoryWorkProgressAtTick, } from "./progress.js";
+export { advanceFactoryReplay, advanceFactoryReplayCheckpoint, canonicalizeFactoryEvents, createFactoryReplayWorldCheckpoint, initializeFactoryReplay, projectFactoryStateAtTick, projectFactoryWorldAtTick, } from "./replay.js";
+export { FACTORY_TOPOLOGY_RELATIONSHIPS, factoryTopologyEntityId, factoryTopologyNodeId, projectFactoryTopology, projectFactoryTopologyAtTick, projectFactoryTopologyConnection, } from "./topology.js";

package/dist/load-contract.d.ts

@@ -0,0 +1,57 @@
+import type { FactoryDefinition, FactoryEvent } from "@you-agent-factory/client";
+export interface FactoryWorkStateOccupancyEvidence {
+    id: string;
+    stateId?: string;
+    stateName?: string;
+    workTypeId?: string;
+}
+export interface FactoryResourceClaimEvidence {
+    resourceName: string;
+    quantity?: number;
+}
+export interface FactoryActiveResourceClaimsEvidence {
+    id: string;
+    resourceClaims?: readonly FactoryResourceClaimEvidence[];
+}
+export interface FactoryWorkStateCountProjection {
+    count?: number;
+    evidence: "known" | "unavailable";
+    workIds?: string[];
+    workStateId: string;
+    workStateNodeId: string;
+    workTypeId: string;
+}
+export interface FactoryResourceOccupancyProjection {
+    availableQuantity?: number;
+    capacity?: number;
+    capacityEvidence: "known" | "unavailable";
+    evidence: "known" | "unavailable";
+    occupiedQuantity?: number;
+    resourceId: string;
+    resourceNodeId: string;
+}
+export interface FactoryLoadProjectionIssue {
+    code: "CONTRADICTORY_RESOURCE_CLAIM" | "CONTRADICTORY_WORK_STATE" | "INVALID_RESOURCE_CAPACITY" | "MISSING_FACTORY" | "RESOURCE_CAPACITY_EXCEEDED" | "UNRESOLVED_RESOURCE_CLAIM" | "UNRESOLVED_WORK_STATE";
+    dispatchId?: string;
+    id: string;
+    message: string;
+    reference?: string;
+    resourceId?: string;
+    workId?: string;
+}
+export interface FactoryLoadProjection {
+    issues: FactoryLoadProjectionIssue[];
+    resourceOccupancy: FactoryResourceOccupancyProjection[];
+    selectedTick: number;
+    workStateCounts: FactoryWorkStateCountProjection[];
+}
+export interface FactoryLoadProjectionInput {
+    activeDispatches?: readonly FactoryActiveResourceClaimsEvidence[];
+    factory?: FactoryDefinition;
+    selectedTick: number;
+    works?: readonly FactoryWorkStateOccupancyEvidence[];
+}
+export interface FactoryLoadAtTickInput {
+    events: readonly FactoryEvent[];
+    tick: number;
+}

package/dist/load-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/load-replay.d.ts

@@ -0,0 +1,3 @@
+import type { FactoryLoadAtTickInput, FactoryLoadProjection } from "./load-contract.js";
+/** Reconstruct Work State counts and resource occupancy at one logical tick. */
+export declare function projectFactoryLoadAtTick(input: FactoryLoadAtTickInput): FactoryLoadProjection;

package/dist/load-replay.js

@@ -0,0 +1,156 @@
+import { projectFactoryLoad } from "./load.js";
+import { canonicalizeFactoryEvents } from "./replay.js";
+/** Reconstruct Work State counts and resource occupancy at one logical tick. */
+export function projectFactoryLoadAtTick(input) {
+    const state = {
+        activeDispatches: new Map(),
+        works: new Map(),
+    };
+    for (const event of canonicalizeFactoryEvents(input.events)) {
+        if (event.context.tick > input.tick)
+            break;
+        applyLoadEvent(state, event);
+    }
+    return projectFactoryLoad({
+        activeDispatches: [...state.activeDispatches.values()],
+        factory: state.factory,
+        selectedTick: input.tick,
+        works: [...state.works.values()],
+    });
+}
+function applyLoadEvent(state, event) {
+    const payload = objectRecord(event.payload);
+    if (event.type === "INITIAL_STRUCTURE_REQUEST" ||
+        event.type === "FACTORY_CHANGE") {
+        const factory = objectRecord(payload?.factory);
+        if (factory)
+            state.factory = structuredClone(factory);
+        return;
+    }
+    if (event.type === "WORK_REQUEST") {
+        applyWorkRequest(state, payload);
+        return;
+    }
+    if (event.type === "WORK_STATE_CHANGE") {
+        applyWorkStateChange(state, payload);
+        return;
+    }
+    if (event.type === "DISPATCH_REQUEST") {
+        applyDispatchRequest(state, event, payload);
+        return;
+    }
+    if (event.type === "DISPATCH_RESPONSE") {
+        applyDispatchResponse(state, event, payload);
+    }
+}
+function applyWorkRequest(state, payload) {
+    for (const value of arrayValue(payload?.works)) {
+        const work = workEvidence(value);
+        if (!work)
+            continue;
+        state.works.set(work.id, withInitialState(work, state.factory));
+    }
+}
+function applyWorkStateChange(state, payload) {
+    if (typeof payload?.workId !== "string" || !payload.workId)
+        return;
+    const previous = state.works.get(payload.workId);
+    state.works.set(payload.workId, {
+        id: payload.workId,
+        ...(typeof payload.toState === "string"
+            ? { stateName: payload.toState }
+            : {}),
+        ...(typeof payload.workTypeName === "string"
+            ? { workTypeId: payload.workTypeName }
+            : previous?.workTypeId
+                ? { workTypeId: previous.workTypeId }
+                : {}),
+    });
+}
+function applyDispatchRequest(state, event, payload) {
+    const dispatchId = event.context.dispatchId;
+    const inputIds = arrayValue(payload?.inputs).flatMap((value) => {
+        const input = objectRecord(value);
+        return typeof input?.workId === "string" && input.workId
+            ? [input.workId]
+            : [];
+    });
+    for (const workId of new Set([
+        ...(event.context.workIds ?? []),
+        ...inputIds,
+    ])) {
+        state.works.delete(workId);
+    }
+    if (!dispatchId) {
+        state.activeDispatches.set(`incomplete:${event.id}`, {
+            id: `incomplete:${event.id}`,
+        });
+        return;
+    }
+    const resourceValues = Array.isArray(payload?.resources)
+        ? payload.resources
+        : undefined;
+    const resources = resourceValues
+        ? resourceValues.flatMap((value) => {
+            const resource = objectRecord(value);
+            return typeof resource?.name === "string" && resource.name
+                ? [{ resourceName: resource.name }]
+                : [];
+        })
+        : undefined;
+    const hasCompleteResourceEvidence = resources !== undefined && resources.length === resourceValues?.length;
+    state.activeDispatches.set(dispatchId, {
+        id: dispatchId,
+        ...(hasCompleteResourceEvidence ? { resourceClaims: resources } : {}),
+    });
+}
+function applyDispatchResponse(state, event, payload) {
+    if (event.context.dispatchId) {
+        state.activeDispatches.delete(event.context.dispatchId);
+    }
+    else {
+        state.activeDispatches.set(`incomplete:${event.id}`, {
+            id: `incomplete:${event.id}`,
+        });
+    }
+    for (const value of arrayValue(payload?.outputWork)) {
+        const work = workEvidence(value);
+        if (work)
+            state.works.set(work.id, withInitialState(work, state.factory));
+    }
+}
+function workEvidence(value) {
+    const work = objectRecord(value);
+    if (typeof work?.workId !== "string" || !work.workId)
+        return undefined;
+    const state = objectRecord(work.state);
+    return {
+        id: work.workId,
+        ...(typeof state?.id === "string" ? { stateId: state.id } : {}),
+        ...(typeof state?.name === "string" ? { stateName: state.name } : {}),
+        ...(typeof work.workTypeName === "string"
+            ? { workTypeId: work.workTypeName }
+            : {}),
+    };
+}
+function withInitialState(work, factory) {
+    if (work.stateId || work.stateName || !work.workTypeId)
+        return work;
+    const workType = factory?.workTypes?.find((candidate) => candidate.name === work.workTypeId || candidate.id === work.workTypeId);
+    const initial = workType?.states.find((state) => state.type === "INITIAL");
+    return initial
+        ? {
+            ...work,
+            ...(initial.id?.trim() ? { stateId: initial.id } : {}),
+            stateName: initial.name,
+        }
+        : work;
+}
+function objectRecord(value) {
+    return value !== null && typeof value === "object"
+        ? value
+        : undefined;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/load.d.ts

@@ -0,0 +1,3 @@
+import type { FactoryLoadProjection, FactoryLoadProjectionInput } from "./load-contract.js";
+/** Project selected-tick Work State counts and resource occupancy evidence. */
+export declare function projectFactoryLoad(input: FactoryLoadProjectionInput): FactoryLoadProjection;