@pie-players/pie-assessment-toolkit 0.3.74 → 1.0.0-beta.0

package/dist/tools/registrations/toolbar-registration-helpers.d.ts

@@ -1,5 +1,11 @@
 import type { ToolToolbarButtonDefinition, ToolToolbarRenderResult, ToolbarContext } from "../../services/ToolRegistry.js";
 export type ToolOverlaySurface = "default" | "frameless";
+/**
+ * The event a tool element dispatches, bubbling and composed, with
+ * `{ active: boolean }` as its detail when it opens or closes its own panel.
+ * A registration relays it as the toolbar button's active state.
+ */
+export declare const TOOL_ACTIVE_CHANGE_EVENT = "pie-tool-active-change";
 export declare function createScopedVisibilityBinding(toolId: string, toolbarContext: ToolbarContext): {
     fullToolId: string;
     isActive: () => boolean;

package/dist/tools/registrations/toolbar-registration-helpers.js

@@ -1,14 +1,20 @@
 import { createScopedToolId } from "../../services/tool-instance-id.js";
+/**
+ * The event a tool element dispatches, bubbling and composed, with
+ * `{ active: boolean }` as its detail when it opens or closes its own panel.
+ * A registration relays it as the toolbar button's active state.
+ */
+export const TOOL_ACTIVE_CHANGE_EVENT = "pie-tool-active-change";
 export function createScopedVisibilityBinding(toolId, toolbarContext) {
     const fullToolId = createScopedToolId(toolId, toolbarContext.scope.level, toolbarContext.scope.scopeId);
     return {
         fullToolId,
-        isActive: () => toolbarContext.isToolVisible(fullToolId),
+        isActive: () => toolbarContext.isToolVisible(toolId),
         subscribeActive: (callback) => {
             if (!toolbarContext.subscribeVisibility)
                 return () => { };
             return toolbarContext.subscribeVisibility(() => {
-                callback(toolbarContext.isToolVisible(fullToolId));
+                callback(toolbarContext.isToolVisible(toolId));
             });
         },
     };

package/dist/tools/tool-surface-host.d.ts

@@ -1,19 +1,15 @@
 /**
  * Headless host for capabilities that render into a renderer's surfaces.
  *
- * The interface deliberately exposes only current input, a two-boolean snapshot,
- * and teardown. Discovery, policy/catalog invalidation, content resolution, lazy
+ * The interface exposes only current input, a two-boolean snapshot, and
+ * teardown. Discovery, policy/catalog invalidation, content resolution, lazy
  * loading, DOM reconciliation, error isolation, and registry observation stay
  * inside this module. Svelte callers are geometry adapters over this seam.
  *
- * It lives here rather than in `section-player`, where it was written, because a
- * second renderer now opens a surface: the annotation toolbar hosts the
- * capabilities that act on a text selection. Two copies of mount/reconcile/
- * registry-observation would drift, and the drift would be invisible until one
- * renderer stopped honouring the grant-AND-content rule. Nothing about the module
- * was section-shaped — it already imported only from this package — so the move
- * is a relocation, not a rewrite. The one thing that *was* section-shaped is the
- * name it reported errors under, which is now {@link ToolSurfaceHostOptions.hostLabel}.
+ * Every renderer that opens a surface shares this one host, so each honours the
+ * grant-AND-content rule the same way: the section player's cards and the
+ * annotation toolbar's selection surface. Errors are reported under
+ * {@link ToolSurfaceHostOptions.hostLabel}.
  */
 import type { CatalogOwnerContext } from "../services/catalog-owner.js";
 import type { ToolRegistry, ToolSurfaceServices } from "../services/ToolRegistry.js";

package/dist/tools/tool-surface-host.js

@@ -1,23 +1,33 @@
 /**
  * Headless host for capabilities that render into a renderer's surfaces.
  *
- * The interface deliberately exposes only current input, a two-boolean snapshot,
- * and teardown. Discovery, policy/catalog invalidation, content resolution, lazy
+ * The interface exposes only current input, a two-boolean snapshot, and
+ * teardown. Discovery, policy/catalog invalidation, content resolution, lazy
  * loading, DOM reconciliation, error isolation, and registry observation stay
  * inside this module. Svelte callers are geometry adapters over this seam.
  *
- * It lives here rather than in `section-player`, where it was written, because a
- * second renderer now opens a surface: the annotation toolbar hosts the
- * capabilities that act on a text selection. Two copies of mount/reconcile/
- * registry-observation would drift, and the drift would be invisible until one
- * renderer stopped honouring the grant-AND-content rule. Nothing about the module
- * was section-shaped — it already imported only from this package — so the move
- * is a relocation, not a rewrite. The one thing that *was* section-shaped is the
- * name it reported errors under, which is now {@link ToolSurfaceHostOptions.hostLabel}.
+ * Every renderer that opens a surface shares this one host, so each honours the
+ * grant-AND-content rule the same way: the section player's cards and the
+ * annotation toolbar's selection surface. Errors are reported under
+ * {@link ToolSurfaceHostOptions.hostLabel}.
  */
 import { isHostDeniedFeature } from "../policy/core/feature-decision.js";
 import { toFrameworkErrorModel } from "../services/framework-error.js";
 import { resolveContentCapabilities } from "./content-capability-resolution.js";
+/**
+ * The scope an item's content asks feature policy with, which brings in the
+ * item's settings; other owners ask unscoped.
+ */
+function itemFeatureScope(owner) {
+    if (owner.ownerKind !== "itemModel")
+        return undefined;
+    return {
+        level: "item",
+        scopeId: owner.canonicalItemId || owner.itemId,
+        itemId: owner.itemId,
+        canonicalItemId: owner.canonicalItemId,
+    };
+}
 const SECTION_POLICY_LEVELS = ["section", "item", "passage"];
 function stableSerializableJson(value) {
     const seen = new Set();
@@ -33,12 +43,6 @@ function stableSerializableJson(value) {
         if (typeof current === "undefined") {
             return undefined;
         }
-        if (typeof current === "function" || typeof current === "symbol") {
-            throw new TypeError(`${path} is not JSON-serializable`);
-        }
-        if (typeof current === "bigint") {
-            throw new TypeError(`${path} is not JSON-serializable`);
-        }
         if (typeof current !== "object") {
             throw new TypeError(`${path} is not JSON-serializable`);
         }
@@ -112,7 +116,7 @@ function contextSignature(context) {
     try {
         return stableSerializableJson({
             toolId: context.toolId,
-            featureId: context.featureId,
+            granted: context.granted,
             surface: context.surface,
             parameters: context.parameters ?? null,
             content: context.content ?? null,
@@ -235,26 +239,22 @@ export function createToolSurfaceHost(onSnapshot, options) {
         if (current.scope.kind !== "content")
             return null;
         const coordinator = current.services.toolkitCoordinator;
+        const featureScope = itemFeatureScope(current.scope.ownerContext);
         const [resolved] = resolveContentCapabilities({
             registrations: [registration],
             catalogs,
-            // One decision per feature id, in the rule's three states. The scan across
-            // a capability's support ids, the gate-only probe of its tool id, and
-            // denial's precedence over both a grant and `resolvesWithoutGrant` live in
-            // the rule, so this host and print cannot answer differently. All this
-            // adapter owns is reading a `FeaturePolicyDecision`: `granted` is not
-            // enough on its own, because a host gate and an unconfigured feature are
-            // both `granted: false` and only one of them may be reopened by content.
-            policyFor: (featureId) => {
-                const decision = coordinator?.decideFeaturePolicy?.(featureId);
+            // One decision per support id, in the rule's three states. Denial's
+            // precedence over both a grant and `resolvesWithoutGrant` lives in the
+            // rule, so this host and print cannot answer differently. All this adapter
+            // owns is reading a `FeaturePolicyDecision`: `granted` is not enough on its
+            // own, because a host gate and an unconfigured feature are both
+            // `granted: false` and only one of them may be reopened by content.
+            policyFor: (supportId) => {
+                const decision = coordinator?.decideFeaturePolicy?.(supportId, featureScope);
                 if (isHostDeniedFeature(decision))
                     return { outcome: "denied" };
                 if (decision?.granted === true) {
-                    return {
-                        outcome: "granted",
-                        featureId,
-                        parameters: decision.parameters,
-                    };
+                    return { outcome: "granted", parameters: decision.parameters };
                 }
                 return { outcome: "silent" };
             },
@@ -281,7 +281,7 @@ export function createToolSurfaceHost(onSnapshot, options) {
         }
         const context = {
             toolId: registration.toolId,
-            featureId: resolved.featureId,
+            granted: resolved.granted,
             surface: current.surface,
             parameters: resolved.parameters,
             content: resolved.content,
@@ -303,26 +303,19 @@ export function createToolSurfaceHost(onSnapshot, options) {
         const coordinator = current.services.toolkitCoordinator;
         if (!coordinator)
             return null;
-        const supportIds = registration.pnpSupportIds?.length
-            ? registration.pnpSupportIds
-            : [registration.toolId];
-        let featureId = "";
+        let granted = false;
         let parameters;
         try {
             if (registration.activation === "region") {
-                for (const supportId of supportIds) {
-                    const decision = coordinator.decideFeaturePolicy?.(supportId);
-                    if (decision?.granted !== true)
-                        continue;
-                    featureId = supportId;
-                    parameters = decision.parameters;
-                    break;
-                }
-                if (!featureId)
+                const decision = coordinator.decideFeaturePolicy?.(registration.toolId);
+                if (decision?.granted !== true)
                     return null;
+                granted = true;
+                parameters = decision.parameters;
             }
             else {
                 const scopeId = current.scope.sectionId || "*";
+                let placed = false;
                 for (const level of SECTION_POLICY_LEVELS) {
                     const decision = coordinator.decideToolPolicy({
                         level,
@@ -336,11 +329,14 @@ export function createToolSurfaceHost(onSnapshot, options) {
                     const entry = decision.visibleTools.find((candidate) => candidate.toolId === registration.toolId);
                     if (!entry)
                         continue;
-                    featureId = supportIds[0] ?? registration.toolId;
-                    parameters = entry.settings;
+                    // Placement admits the tool; only a support, requirement or
+                    // test-administration override grants it.
+                    placed = true;
+                    granted = entry.required || entry.alwaysAvailable;
+                    parameters = entry.parameters;
                     break;
                 }
-                if (!featureId)
+                if (!placed)
                     return null;
             }
         }
@@ -350,7 +346,7 @@ export function createToolSurfaceHost(onSnapshot, options) {
         }
         const context = {
             toolId: registration.toolId,
-            featureId,
+            granted,
             surface: current.surface,
             parameters,
             services: current.services,
@@ -463,7 +459,6 @@ export function createToolSurfaceHost(onSnapshot, options) {
                 }
             }
             report(toolId, "render", `Tool "${toolId}" failed to render into the "${current.surface}" surface.`, error);
-            return;
         }
     }
     function reconcile() {

package/dist/tools/tool-tag-map.d.ts

@@ -10,26 +10,16 @@ export type ToolComponentFactory = (args: {
 export type ToolComponentFactoryMap = Record<string, ToolComponentFactory>;
 export interface ToolComponentOverrides {
     toolTagMap?: Partial<ToolTagMap>;
-    toolComponentFactory?: ToolComponentFactory;
     toolComponentFactories?: Partial<ToolComponentFactoryMap>;
 }
 /**
- * Resolve the element tag for a tool from the overrides in play.
- *
- * There is no built-in map to fall back to. One lived here, naming eleven
- * capabilities, and a core module holding that catalogue is why a host could not
- * add a twelfth without editing this package — the map was overridable, but the
- * default was core-resident. The packaged map is `PACKAGED_TOOL_TAG_MAP` in
- * `@pie-players/pie-default-tool-loaders`, installed onto a registry through
+ * Resolve the element tag for a tool from the overrides in play. Core holds no
+ * tag map; the packaged one is `PACKAGED_TOOL_TAG_MAP` in
+ * `@pie-players/pie-default-tool-loaders`, installed through
  * `ToolRegistry.setComponentOverrides`.
  *
- * An unmapped toolId falls through to itself, which is only a valid tag if the
- * host's tool id already looks like one. Every packaged id is a single camelCase
- * word, so in practice an unmapped packaged tool throws here rather than
- * rendering a bogus element — the failure names the missing mapping, because
- * "custom element names must include a hyphen" is a true statement about the
- * wrong thing.
+ * An unmapped toolId is its own tag when it contains a hyphen. Otherwise this
+ * throws an error naming the missing mapping.
  */
 export declare const resolveToolTag: (toolId: string, overrides?: ToolComponentOverrides) => string;
 export declare const createToolElement: (toolId: string, context: ToolContext, toolbarContext: ToolbarContext, overrides?: ToolComponentOverrides) => HTMLElement;
-export declare const toToolIdFromTag: (tagName: string, overrides?: ToolComponentOverrides) => string | undefined;

package/dist/tools/tool-tag-map.js

@@ -1,20 +1,12 @@
 import { validateCustomElementTag } from "@pie-players/pie-players-shared/pie/tag-names";
 /**
- * Resolve the element tag for a tool from the overrides in play.
- *
- * There is no built-in map to fall back to. One lived here, naming eleven
- * capabilities, and a core module holding that catalogue is why a host could not
- * add a twelfth without editing this package — the map was overridable, but the
- * default was core-resident. The packaged map is `PACKAGED_TOOL_TAG_MAP` in
- * `@pie-players/pie-default-tool-loaders`, installed onto a registry through
+ * Resolve the element tag for a tool from the overrides in play. Core holds no
+ * tag map; the packaged one is `PACKAGED_TOOL_TAG_MAP` in
+ * `@pie-players/pie-default-tool-loaders`, installed through
  * `ToolRegistry.setComponentOverrides`.
  *
- * An unmapped toolId falls through to itself, which is only a valid tag if the
- * host's tool id already looks like one. Every packaged id is a single camelCase
- * word, so in practice an unmapped packaged tool throws here rather than
- * rendering a bogus element — the failure names the missing mapping, because
- * "custom element names must include a hyphen" is a true statement about the
- * wrong thing.
+ * An unmapped toolId is its own tag when it contains a hyphen. Otherwise this
+ * throws an error naming the missing mapping.
  */
 export const resolveToolTag = (toolId, overrides) => {
     const mapped = overrides?.toolTagMap?.[toolId];
@@ -26,14 +18,8 @@ export const resolveToolTag = (toolId, overrides) => {
 const createDefaultToolElement = (tagName) => document.createElement(tagName);
 export const createToolElement = (toolId, context, toolbarContext, overrides) => {
     const tagName = resolveToolTag(toolId, overrides);
-    const factoryForTool = overrides?.toolComponentFactories?.[toolId];
-    const factory = factoryForTool ?? overrides?.toolComponentFactory;
+    const factory = overrides?.toolComponentFactories?.[toolId];
     return factory
         ? factory({ toolId, tagName, context, toolbarContext })
         : createDefaultToolElement(tagName);
 };
-export const toToolIdFromTag = (tagName, overrides) => {
-    const validTag = validateCustomElementTag(tagName, "tool component tag");
-    const map = overrides?.toolTagMap ?? {};
-    return Object.entries(map).find(([, tag]) => tag === validTag)?.[0];
-};

package/dist/utils/structural-equality.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Structural equality for plain data: host-supplied policy inputs and session
+ * payloads.
+ *
+ * Plain objects compare by own enumerable keys in any order, a key holding
+ * `undefined` matching an absent one, and arrays compare by position. Every
+ * other value compares with `Object.is`, so class instances, functions and
+ * maps are equal only to themselves. A pair already under comparison counts as
+ * equal, which keeps a cyclic value from recursing forever.
+ */
+export declare function structurallyEqual(a: unknown, b: unknown): boolean;

package/dist/utils/structural-equality.js

@@ -0,0 +1,47 @@
+/**
+ * Structural equality for plain data: host-supplied policy inputs and session
+ * payloads.
+ *
+ * Plain objects compare by own enumerable keys in any order, a key holding
+ * `undefined` matching an absent one, and arrays compare by position. Every
+ * other value compares with `Object.is`, so class instances, functions and
+ * maps are equal only to themselves. A pair already under comparison counts as
+ * equal, which keeps a cyclic value from recursing forever.
+ */
+export function structurallyEqual(a, b) {
+    return compare(a, b, new WeakMap());
+}
+function compare(a, b, inProgress) {
+    if (Object.is(a, b))
+        return true;
+    const aIsArray = Array.isArray(a);
+    if (aIsArray !== Array.isArray(b))
+        return false;
+    if (!aIsArray && (!isPlainObject(a) || !isPlainObject(b)))
+        return false;
+    const left = a;
+    const right = b;
+    if (aIsArray && a.length !== b.length) {
+        return false;
+    }
+    let partners = inProgress.get(left);
+    if (partners?.has(right))
+        return true;
+    if (!partners) {
+        partners = new Set();
+        inProgress.set(left, partners);
+    }
+    partners.add(right);
+    const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
+    for (const key of keys) {
+        if (!compare(left[key], right[key], inProgress))
+            return false;
+    }
+    return true;
+}
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pie-players/pie-assessment-toolkit",
-	"version": "0.3.74",
+	"version": "1.0.0-beta.0",
 	"type": "module",
 	"description": "PIE assessment toolkit: composable services + reference implementation for assessment players and tool coordination",
 	"license": "MIT",
@@ -21,13 +21,13 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
 		},
-		"./tools/client": {
-			"types": "./dist/tools/client.d.ts",
-			"import": "./dist/tools/client.js"
+		"./tools/registration": {
+			"types": "./dist/tools/registration.d.ts",
+			"import": "./dist/tools/registration.js"
 		},
-		"./tools/internal": {
-			"types": "./dist/tools/internal.d.ts",
-			"import": "./dist/tools/internal.js"
+		"./components/item-scope-element": {
+			"types": "./dist/components/item-scope-element.d.ts",
+			"import": "./dist/components/item-scope-element.js"
 		},
 		"./components/item-toolbar-element": {
 			"types": "./dist/components/item-toolbar-element.d.ts",
@@ -45,54 +45,40 @@
 			"types": "./dist/services/AccessibilityCatalogResolver.d.ts",
 			"import": "./dist/services/AccessibilityCatalogResolver.js"
 		},
-		"./services/pnp-standard-features": {
-			"types": "./dist/services/pnp-standard-features.d.ts",
-			"import": "./dist/services/pnp-standard-features.js"
-		},
-		"./services/I18nService": {
-			"types": "./dist/services/I18nService.d.ts",
-			"import": "./dist/services/I18nService.js"
-		},
 		"./runtime/engine": {
 			"types": "./dist/runtime/engine.d.ts",
 			"import": "./dist/runtime/engine.js"
 		},
-		"./runtime/internal": {
-			"types": "./dist/runtime/internal.d.ts",
-			"import": "./dist/runtime/internal.js"
-		},
 		"./policy/engine": {
 			"types": "./dist/policy/engine.d.ts",
 			"import": "./dist/policy/engine.js"
-		},
-		"./policy/internal": {
-			"types": "./dist/policy/internal.d.ts",
-			"import": "./dist/policy/internal.js"
 		}
 	},
+	"customElements": "custom-elements.json",
 	"files": [
 		"dist",
+		"custom-elements.json",
 		"README.md"
 	],
 	"scripts": {
 		"build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json && bun ./scripts/build-ce-components.mjs",
 		"dev": "tsc -p tsconfig.json --watch",
-		"typecheck": "tsc -p tsconfig.json --noEmit",
+		"typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.tests.json",
 		"lint": "biome lint .",
 		"check": "svelte-check --tsconfig ./tsconfig.json",
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@pie-players/pie-calculator": "0.3.74",
-		"@pie-players/pie-context": "0.3.74",
-		"@pie-players/pie-players-shared": "0.3.74",
-		"@pie-players/pie-tts": "0.3.74",
+		"@pie-players/pie-calculator": "1.0.0-beta.0",
+		"@pie-players/pie-context": "1.0.0-beta.0",
+		"@pie-players/pie-players-shared": "1.0.0-beta.0",
+		"@pie-players/pie-tts": "1.0.0-beta.0",
 		"speech-rule-engine": "5.0.0-rc.4"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.15",
 		"@happy-dom/global-registrator": "^20.14.5",
-		"@pie-players/tts-client-server": "0.3.74",
+		"@pie-players/tts-client-server": "1.0.0-beta.0",
 		"svelte": "^5.57.1",
 		"svelte-check": "^4.7.6",
 		"typescript": "^5.9.3"

package/dist/attempt/adapters/activity-to-test-attempt-session.d.ts

@@ -1,49 +0,0 @@
-import type { TestAttemptSession } from "../TestSession.js";
-export interface PieBackendActivityItemRef {
-    identifier?: string;
-    item?: {
-        id?: string;
-        identifier?: string;
-    };
-}
-export interface PieBackendActivityDefinition {
-    id?: string;
-    identifier?: string;
-    assessmentId?: string;
-    assessmentItemRefs?: PieBackendActivityItemRef[];
-}
-export interface PieBackendActivitySession {
-    id?: string;
-    activitySessionId?: string;
-    startedAt?: string;
-    updatedAt?: string;
-    completedAt?: string;
-    currentItemIndex?: number;
-    currentSectionIdentifier?: string;
-    visitedItemIdentifiers?: string[];
-    itemSessions?: Record<string, unknown>;
-}
-export interface MapActivityToTestAttemptSessionArgs {
-    activityDefinition?: PieBackendActivityDefinition | null;
-    activitySession?: PieBackendActivitySession | null;
-    itemRefs?: PieBackendActivityItemRef[];
-    itemSessionsByItemIdentifier?: Record<string, unknown>;
-    assessmentId?: string;
-    testAttemptSessionIdentifier?: string;
-}
-export interface ActivitySessionPatchPayload {
-    activitySession: {
-        id: string;
-        startedAt?: string;
-        updatedAt?: string;
-        completedAt?: string;
-        currentItemIndex: number;
-        currentSectionIdentifier?: string;
-        visitedItemIdentifiers: string[];
-        itemSessions: Record<string, unknown>;
-    };
-}
-export declare function mapActivityToTestAttemptSession(args: MapActivityToTestAttemptSessionArgs): TestAttemptSession;
-export declare function toItemSessionsRecord(testAttemptSession: TestAttemptSession): Record<string, unknown>;
-export declare function buildActivitySessionPatchFromTestAttemptSession(testAttemptSession: TestAttemptSession): ActivitySessionPatchPayload;
-export declare function buildActivitySessionItemUpdate(testAttemptSession: TestAttemptSession, itemIdentifier: string): ActivitySessionPatchPayload;

package/dist/attempt/adapters/activity-to-test-attempt-session.js

@@ -1,138 +0,0 @@
-function nowIso() {
-    return new Date().toISOString();
-}
-function getItemIdentifier(itemRef) {
-    return (itemRef.identifier || itemRef.item?.identifier || itemRef.item?.id || null);
-}
-function resolveItemIdentifiers(args) {
-    const refs = args.itemRefs || args.activityDefinition?.assessmentItemRefs || [];
-    const identifiers = refs
-        .map((itemRef) => getItemIdentifier(itemRef))
-        .filter((itemIdentifier) => !!itemIdentifier);
-    return Array.from(new Set(identifiers));
-}
-function resolveAssessmentId(args) {
-    return (args.assessmentId ||
-        args.activityDefinition?.assessmentId ||
-        args.activityDefinition?.identifier ||
-        args.activityDefinition?.id ||
-        "unknown-assessment");
-}
-function resolveTestAttemptSessionIdentifier(args, assessmentId) {
-    return (args.testAttemptSessionIdentifier ||
-        args.activitySession?.activitySessionId ||
-        args.activitySession?.id ||
-        `tas_${assessmentId}`);
-}
-function resolveBackendItemSessions(args) {
-    return {
-        ...(args.activitySession?.itemSessions || {}),
-        ...(args.itemSessionsByItemIdentifier || {}),
-    };
-}
-function mapItemSessions(itemIdentifiers, backendItemSessions) {
-    return itemIdentifiers.reduce((acc, itemIdentifier) => {
-        const rawSession = backendItemSessions[itemIdentifier];
-        if (!rawSession)
-            return acc;
-        const pieSessionId = typeof rawSession.id === "string" ? rawSession.id : undefined;
-        const attemptCount = typeof rawSession.attemptCount === "number" &&
-            rawSession.attemptCount > 0
-            ? rawSession.attemptCount
-            : pieSessionId
-                ? 1
-                : 0;
-        const isCompleted = typeof rawSession.isCompleted === "boolean"
-            ? rawSession.isCompleted
-            : Boolean(rawSession.complete);
-        const startedAt = typeof rawSession.startedAt === "string"
-            ? rawSession.startedAt
-            : undefined;
-        const updatedAt = typeof rawSession.updatedAt === "string"
-            ? rawSession.updatedAt
-            : undefined;
-        const completedAt = typeof rawSession.completedAt === "string"
-            ? rawSession.completedAt
-            : undefined;
-        acc[itemIdentifier] = {
-            itemIdentifier,
-            pieSessionId,
-            attemptCount,
-            isCompleted,
-            startedAt,
-            updatedAt,
-            completedAt,
-            session: rawSession,
-        };
-        return acc;
-    }, {});
-}
-export function mapActivityToTestAttemptSession(args) {
-    const assessmentId = resolveAssessmentId(args);
-    const itemIdentifiers = resolveItemIdentifiers(args);
-    const testAttemptSessionIdentifier = resolveTestAttemptSessionIdentifier(args, assessmentId);
-    const backendItemSessions = resolveBackendItemSessions(args);
-    const now = nowIso();
-    const startedAt = args.activitySession?.startedAt || now;
-    const updatedAt = args.activitySession?.updatedAt || startedAt;
-    return {
-        version: 1,
-        testAttemptSessionIdentifier,
-        assessmentId,
-        startedAt,
-        updatedAt,
-        completedAt: args.activitySession?.completedAt,
-        navigationState: {
-            currentItemIndex: args.activitySession?.currentItemIndex ?? -1,
-            visitedItemIdentifiers: [
-                ...(args.activitySession?.visitedItemIdentifiers || []),
-            ],
-            currentSectionIdentifier: args.activitySession?.currentSectionIdentifier,
-        },
-        realization: {
-            seed: testAttemptSessionIdentifier,
-            itemIdentifiers,
-        },
-        itemSessions: mapItemSessions(itemIdentifiers, backendItemSessions),
-    };
-}
-export function toItemSessionsRecord(testAttemptSession) {
-    return Object.entries(testAttemptSession.itemSessions).reduce((acc, [itemIdentifier, itemSession]) => {
-        if (itemSession.session) {
-            acc[itemIdentifier] = itemSession.session;
-        }
-        return acc;
-    }, {});
-}
-export function buildActivitySessionPatchFromTestAttemptSession(testAttemptSession) {
-    return {
-        activitySession: {
-            id: testAttemptSession.testAttemptSessionIdentifier,
-            startedAt: testAttemptSession.startedAt,
-            updatedAt: testAttemptSession.updatedAt,
-            completedAt: testAttemptSession.completedAt,
-            currentItemIndex: testAttemptSession.navigationState.currentItemIndex,
-            currentSectionIdentifier: testAttemptSession.navigationState.currentSectionIdentifier,
-            visitedItemIdentifiers: [
-                ...testAttemptSession.navigationState.visitedItemIdentifiers,
-            ],
-            itemSessions: toItemSessionsRecord(testAttemptSession),
-        },
-    };
-}
-export function buildActivitySessionItemUpdate(testAttemptSession, itemIdentifier) {
-    const itemSession = testAttemptSession.itemSessions[itemIdentifier];
-    return {
-        activitySession: {
-            id: testAttemptSession.testAttemptSessionIdentifier,
-            currentItemIndex: testAttemptSession.navigationState.currentItemIndex,
-            currentSectionIdentifier: testAttemptSession.navigationState.currentSectionIdentifier,
-            visitedItemIdentifiers: [
-                ...testAttemptSession.navigationState.visitedItemIdentifiers,
-            ],
-            itemSessions: itemSession?.session
-                ? { [itemIdentifier]: itemSession.session }
-                : {},
-        },
-    };
-}