@beyondwork/docx-react-component 1.0.105 → 1.0.108

package/src/runtime/workflow/overlay-lanes.ts

@@ -0,0 +1,386 @@
+import type {
+  CommentSidebarSnapshot,
+  OverlayKind,
+  SuggestionsSnapshot,
+  TrackedChangesSnapshot,
+  WorkflowMarkupSnapshot,
+  WorkflowScopeSnapshot,
+} from "../../api/public-types.ts";
+import { ISSUE_METADATA_ID } from "../../api/public-types.ts";
+import type {
+  WorkflowOverlayLaneEntry,
+  WorkflowOverlayLaneKind,
+  WorkflowOverlayLaneSnapshot,
+  WorkflowOverlayLaneStatus,
+} from "./overlay-lane-types.ts";
+
+export type WorkflowReviewOverlayLaneKind = Extract<
+  WorkflowOverlayLaneKind,
+  "redlines" | "comments" | "issues" | "field-scopes" | "broad-scopes" | "presence"
+>;
+export type WorkflowReviewOverlayLaneSnapshot = WorkflowOverlayLaneSnapshot;
+export type WorkflowReviewOverlayLaneListener = (
+  snapshot: WorkflowReviewOverlayLaneSnapshot,
+) => void;
+export type WorkflowReviewOverlayLaneRefreshEvent = {
+  readonly type:
+    | "ready"
+    | "comment_added"
+    | "comment_resolved"
+    | "comments_changed"
+    | "change_authored"
+    | "change_accepted"
+    | "change_rejected"
+    | "suggestion_authored"
+    | "suggestion_updated"
+    | "workflow_metadata_changed"
+    | "workflow_overlay_changed"
+    | "workflow_active_work_item_changed"
+    | "workflow_shared_state_changed"
+    | "workflow_visibility_policy_changed"
+    | "workflow_markup_mode_policy_changed"
+    | "toc_auto_refreshed"
+    | "warning_added"
+    | "warning_cleared"
+    | "error"
+    | string;
+  readonly kind?: unknown;
+};
+
+export interface WorkflowReviewOverlayLaneInput {
+  readonly comments?: CommentSidebarSnapshot;
+  readonly trackedChanges?: TrackedChangesSnapshot;
+  readonly suggestions?: SuggestionsSnapshot | null;
+  readonly workflowScope?: WorkflowScopeSnapshot;
+  readonly workflowMarkup?: WorkflowMarkupSnapshot;
+  readonly revision?: number;
+}
+
+/**
+ * Layer-06 data handoff for L10/L11 PE2 overlay lanes.
+ *
+ * This projector emits plain lane snapshots only. It does not resolve geometry,
+ * read DOM state, subscribe to awareness, dispatch PM transactions, or wake
+ * layout. Presence is intentionally unavailable here because live cursor/
+ * collaborator state is sourced from Yjs awareness, not durable workflow truth.
+ */
+export function projectWorkflowReviewOverlayLane(
+  kind: WorkflowReviewOverlayLaneKind,
+  input: WorkflowReviewOverlayLaneInput,
+): WorkflowOverlayLaneSnapshot {
+  if (kind === "presence") {
+    return {
+      kind,
+      status: "unavailable",
+      entries: [],
+      revision: input.revision ?? 0,
+      source: "awareness",
+      reason: "presence lane is sourced from Yjs awareness, not durable workflow/review state",
+    };
+  }
+
+  const entries = projectEntries(kind, input);
+  return {
+    kind,
+    status: summarizeStatus(entries),
+    entries,
+    revision: input.revision ?? 0,
+    source: "workflow",
+  };
+}
+
+export function shouldRefreshWorkflowReviewOverlayLane(
+  kind: WorkflowReviewOverlayLaneKind,
+  event: WorkflowReviewOverlayLaneRefreshEvent,
+): boolean {
+  if (kind === "presence") return false;
+  switch (event.type) {
+    case "ready":
+      return true;
+    case "comment_added":
+    case "comment_resolved":
+    case "comments_changed":
+      return kind === "comments";
+    case "change_authored":
+    case "change_accepted":
+    case "change_rejected":
+    case "suggestion_authored":
+    case "suggestion_updated":
+      return kind === "redlines";
+    case "workflow_metadata_changed":
+      return kind === "issues" || kind === "broad-scopes";
+    case "workflow_overlay_changed":
+    case "workflow_active_work_item_changed":
+    case "workflow_shared_state_changed":
+      return kind === "issues" || kind === "broad-scopes";
+    case "workflow_visibility_policy_changed":
+      return shouldRefreshForVisibilityPolicy(
+        kind,
+        isOverlayKind(event.kind) ? event.kind : undefined,
+      );
+    case "workflow_markup_mode_policy_changed":
+      return kind === "redlines";
+    case "toc_auto_refreshed":
+    case "warning_added":
+    case "warning_cleared":
+    case "error":
+      return kind === "field-scopes";
+    default:
+      return false;
+  }
+}
+
+export function areWorkflowReviewOverlayLaneSnapshotsEqual(
+  left: WorkflowReviewOverlayLaneSnapshot,
+  right: WorkflowReviewOverlayLaneSnapshot,
+): boolean {
+  return (
+    left.kind === right.kind &&
+    left.status === right.status &&
+    left.source === right.source &&
+    left.reason === right.reason &&
+    entriesEqual(left.entries, right.entries)
+  );
+}
+
+function isOverlayKind(value: unknown): value is OverlayKind {
+  return (
+    value === "scope-rail" ||
+    value === "comments" ||
+    value === "tracked-changes" ||
+    value === "suggestions" ||
+    value === "debug-panel" ||
+    value === "presence"
+  );
+}
+
+function shouldRefreshForVisibilityPolicy(
+  kind: Exclude<WorkflowReviewOverlayLaneKind, "presence">,
+  overlayKind: OverlayKind | undefined,
+): boolean {
+  switch (overlayKind) {
+    case "comments":
+      return kind === "comments";
+    case "tracked-changes":
+    case "suggestions":
+      return kind === "redlines";
+    case "scope-rail":
+      return kind === "broad-scopes";
+    case "presence":
+    case "debug-panel":
+    case undefined:
+      return false;
+  }
+}
+
+function projectEntries(
+  kind: Exclude<WorkflowReviewOverlayLaneKind, "presence">,
+  input: WorkflowReviewOverlayLaneInput,
+): WorkflowOverlayLaneEntry[] {
+  switch (kind) {
+    case "comments":
+      return (input.comments?.threads ?? []).map((thread) => ({
+        id: thread.commentId,
+        status: thread.status === "detached" ? "requires-rehydration" : "resolved",
+        anchor: { kind: "comment", value: thread.commentId },
+        reason: thread.detachedReason,
+        data: compactData({
+          laneItemKind: "comment",
+          commentId: thread.commentId,
+          editorAnchor: thread.anchor,
+          status: thread.status,
+          createdAt: thread.createdAt,
+          createdBy: thread.createdBy,
+          entryCount: thread.entryCount,
+          warningCount: thread.warningCount,
+          linkedRevisionId: thread.linkedRevisionId,
+          excerpt: thread.excerpt,
+          anchorLabel: thread.anchorLabel,
+        }),
+      }));
+    case "redlines":
+      return (input.trackedChanges?.revisions ?? []).map((revision) => ({
+        id: revision.revisionId,
+        status: revision.status === "detached" ? "requires-rehydration" : "resolved",
+        anchor: { kind: "revision", value: revision.revisionId },
+        reason: revision.preserveOnlyReason,
+        data: compactData({
+          laneItemKind: "revision",
+          revisionId: revision.revisionId,
+          editorAnchor: revision.anchor,
+          revisionKind: revision.kind,
+          semanticKind: revision.semanticKind,
+          suggestionId: revision.suggestionId,
+          status: revision.status,
+          actionability: revision.actionability,
+          authorId: revision.authorId,
+          createdAt: revision.createdAt,
+          label: revision.label,
+          excerpt: revision.excerpt,
+          storyTarget: revision.storyTarget,
+          canAccept: revision.canAccept,
+          canReject: revision.canReject,
+          warningCount: revision.warningCount,
+          commentThreadIds: revision.commentThreadIds,
+        }),
+      }));
+    case "issues":
+      return projectIssueEntries(input);
+    case "field-scopes":
+      return (input.workflowMarkup?.fields ?? []).map((field) => ({
+        id: `field:${field.fieldIndex}`,
+        status: "resolved",
+        data: compactData({
+          laneItemKind: "field",
+          fieldIndex: field.fieldIndex,
+          editorAnchor: field.anchor,
+          fieldFamily: field.fieldFamily,
+          fieldTarget: field.fieldTarget,
+          refreshStatus: field.refreshStatus,
+          displayText: field.displayText,
+          label: field.label,
+          storyTarget: field.storyTarget,
+        }),
+      }));
+    case "broad-scopes":
+      return [
+        ...(input.workflowScope?.scopes ?? []).map((scope) => ({
+          id: scope.scopeId,
+          status: "resolved" as const,
+          anchor: { kind: "scope" as const, value: scope.scopeId },
+          data: compactData({
+            laneItemKind: "workflow-scope",
+            scopeId: scope.scopeId,
+            editorAnchor: scope.anchor,
+            mode: scope.mode,
+            label: scope.label,
+            domain: scope.domain,
+            workItemId: scope.workItemId,
+            visibility: scope.visibility,
+            guardPolicy: scope.guardPolicy,
+            storyTarget: scope.storyTarget,
+            metadataRefs: scope.metadataRefs,
+          }),
+        })),
+        ...(input.workflowScope?.candidates ?? []).map((candidate) => ({
+          id: candidate.candidateId,
+          status: "resolved" as const,
+          data: compactData({
+            laneItemKind: "workflow-candidate",
+            candidateId: candidate.candidateId,
+            editorAnchor: candidate.anchor,
+            label: candidate.label,
+            source: candidate.source,
+            storyTarget: candidate.storyTarget,
+          }),
+        })),
+      ];
+  }
+}
+
+function projectIssueEntries(input: WorkflowReviewOverlayLaneInput): WorkflowOverlayLaneEntry[] {
+  const suggestionGroupsByIssueId = new Map<string, string[]>();
+  for (const group of input.suggestions?.groups ?? []) {
+    if (!group.issueId) continue;
+    const ids = suggestionGroupsByIssueId.get(group.issueId) ?? [];
+    ids.push(group.groupId);
+    suggestionGroupsByIssueId.set(group.issueId, ids);
+  }
+
+  return (input.workflowMarkup?.metadata ?? [])
+    .filter((entry) => entry.metadataId === ISSUE_METADATA_ID)
+    .map((entry) => {
+      const issueValue = isRecord(entry.value) ? entry.value : undefined;
+      const issueId = typeof issueValue?.issueId === "string" ? issueValue.issueId : undefined;
+      return {
+        id: issueId ?? entry.entryId,
+        status: "resolved",
+        anchor: entry.scopeId ? { kind: "scope", value: entry.scopeId } : undefined,
+        data: compactData({
+          laneItemKind: "issue",
+          entryId: entry.entryId,
+          metadataId: entry.metadataId,
+          issueId,
+          editorAnchor: entry.anchor,
+          scopeId: entry.scopeId,
+          workItemId: entry.workItemId,
+          label: entry.label,
+          title: typeof issueValue?.title === "string" ? issueValue.title : undefined,
+          topic: typeof issueValue?.topic === "string" ? issueValue.topic : undefined,
+          severity: typeof issueValue?.severity === "string" ? issueValue.severity : undefined,
+          checklistState:
+            typeof issueValue?.checklistState === "string" ? issueValue.checklistState : undefined,
+          suggestionGroupIds: issueId ? suggestionGroupsByIssueId.get(issueId) ?? [] : [],
+          persistence: entry.persistence,
+          metadataPersistence: entry.metadataPersistence,
+          storageRef: entry.storageRef,
+          metadataVersion: entry.metadataVersion,
+        }),
+      };
+    });
+}
+
+function summarizeStatus(entries: readonly WorkflowOverlayLaneEntry[]): WorkflowOverlayLaneStatus {
+  return entries.some((entry) => entry.status === "requires-rehydration")
+    ? "requires-rehydration"
+    : "resolved";
+}
+
+function entriesEqual(
+  left: readonly WorkflowOverlayLaneEntry[],
+  right: readonly WorkflowOverlayLaneEntry[],
+): boolean {
+  if (left.length !== right.length) return false;
+  for (let index = 0; index < left.length; index += 1) {
+    const leftEntry = left[index];
+    const rightEntry = right[index];
+    if (!leftEntry || !rightEntry) return false;
+    if (
+      leftEntry.id !== rightEntry.id ||
+      leftEntry.status !== rightEntry.status ||
+      leftEntry.reason !== rightEntry.reason ||
+      !jsonValueEqual(leftEntry.anchor, rightEntry.anchor) ||
+      !jsonValueEqual(leftEntry.rects, rightEntry.rects) ||
+      !jsonValueEqual(leftEntry.data, rightEntry.data)
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function jsonValueEqual(left: unknown, right: unknown): boolean {
+  return stableJson(left) === stableJson(right);
+}
+
+function stableJson(value: unknown): string {
+  return JSON.stringify(sortJsonValue(value));
+}
+
+function sortJsonValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (!isRecord(value)) {
+    return value;
+  }
+  const sorted: Record<string, unknown> = {};
+  for (const key of Object.keys(value).sort()) {
+    sorted[key] = sortJsonValue(value[key]);
+  }
+  return sorted;
+}
+
+function compactData(input: Record<string, unknown>): Readonly<Record<string, unknown>> {
+  const output: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== undefined) {
+      output[key] = value;
+    }
+  }
+  return output;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/runtime/workflow/overlay-store.ts

@@ -22,8 +22,8 @@
  *
  * What it does NOT own (by design — those belong to the coordinator):
  *   - interaction-guard / workflow-scope / workflow-markup snapshot
- *     caches (require runtime-scope deps like revisionToken, render
- *     snapshot, selection).
+ *     caches (require runtime-scope deps like render snapshot,
+ *     selection, protection, and active story).
  *   - blocked-reason composition + scope-matching heuristics (require
  *     protection snapshot + viewState.documentMode).
  *   - rail / card composition (requires page graph + render frame).

package/src/runtime/workflow/redline-posture-calibration.ts

@@ -0,0 +1,257 @@
+export type WorkflowRedlinePosture = "all-markup" | "final" | "original" | "unknown";
+
+export interface WorkflowRedlineDatasetDocumentLike {
+  readonly docId: string;
+  readonly status: string;
+  readonly pages: number;
+  readonly revisions: number;
+  readonly comments: number;
+  readonly fields?: number;
+  readonly uiaLines?: number;
+  readonly datasetPath?: string;
+}
+
+export interface WorkflowRedlineDatasetManifestLike {
+  readonly schemaVersion: string;
+  readonly sourceRun: string;
+  readonly captureMatrix?: {
+    readonly markupModes?: readonly string[];
+  };
+  readonly targetedWord?: {
+    readonly version?: string;
+    readonly build?: string;
+    readonly activePrinter?: string;
+  };
+  readonly documents: readonly WorkflowRedlineDatasetDocumentLike[];
+}
+
+export interface WorkflowRedlineFieldIdentityTotalsLike {
+  readonly wordFields: number;
+  readonly joined: number;
+  readonly missingSourceField: number;
+  readonly missingCanonicalField: number;
+  readonly missingRuntimeRegion: number;
+  readonly actionableL04: number;
+}
+
+export type WorkflowRedlinePostureFactId =
+  | "all-markup-review-posture"
+  | "revision-comment-counts"
+  | "clean-all-markup-measurement-handoff"
+  | "redline-field-identity-posture";
+
+export type WorkflowRedlinePostureRepresentation =
+  | "durable-workflow-review-posture"
+  | "measurement-handoff"
+  | "field-region-posture-handoff"
+  | "blocked-until-identity-join";
+
+export interface WorkflowRedlinePostureFact {
+  readonly factId: WorkflowRedlinePostureFactId;
+  readonly representation: WorkflowRedlinePostureRepresentation;
+  readonly posture: WorkflowRedlinePosture;
+  readonly sourceRun: string;
+  readonly l06Surfaces: readonly string[];
+  readonly downstreamRoutes: readonly string[];
+  readonly evidence: Readonly<Record<string, number | string | boolean>>;
+  readonly note: string;
+}
+
+export interface WorkflowRedlinePostureCalibration {
+  readonly schemaVersion: "l06-redline-posture-calibration/v0";
+  readonly facts: readonly WorkflowRedlinePostureFact[];
+  readonly summary: {
+    readonly documentCount: number;
+    readonly availableDocumentCount: number;
+    readonly pageCount: number;
+    readonly revisionCount: number;
+    readonly commentCount: number;
+    readonly fieldCount: number;
+    readonly uiaLineCount: number;
+    readonly posture: WorkflowRedlinePosture;
+    readonly downstreamRouteCount: number;
+    readonly l04ActionableFieldRows: number;
+    readonly ownsGeometry: false;
+    readonly ownsVisualPaint: false;
+  };
+}
+
+export interface WorkflowRedlinePostureCalibrationInput {
+  readonly manifest: WorkflowRedlineDatasetManifestLike;
+  readonly fieldIdentityTotals?: WorkflowRedlineFieldIdentityTotalsLike;
+}
+
+interface WorkflowRedlinePostureTotals {
+  readonly documentCount: number;
+  readonly availableDocumentCount: number;
+  readonly pageCount: number;
+  readonly revisionCount: number;
+  readonly commentCount: number;
+  readonly fieldCount: number;
+  readonly uiaLineCount: number;
+}
+
+export function calibrateWorkflowReviewRedlinePosture(
+  input: WorkflowRedlinePostureCalibrationInput,
+): WorkflowRedlinePostureCalibration {
+  const documents = input.manifest.documents;
+  const availableDocuments = documents.filter((document) => document.status === "available");
+  const posture = resolvePosture(input.manifest.captureMatrix?.markupModes);
+  const totals = {
+    documentCount: documents.length,
+    availableDocumentCount: availableDocuments.length,
+    pageCount: sum(availableDocuments, (document) => document.pages),
+    revisionCount: sum(availableDocuments, (document) => document.revisions),
+    commentCount: sum(availableDocuments, (document) => document.comments),
+    fieldCount: sum(availableDocuments, (document) => document.fields ?? 0),
+    uiaLineCount: sum(availableDocuments, (document) => document.uiaLines ?? 0),
+  };
+
+  const facts = [
+    buildAllMarkupPostureFact(input.manifest, posture, totals),
+    buildReviewCountFact(input.manifest, posture, totals),
+    buildMeasurementHandoffFact(input.manifest, posture, totals),
+    buildFieldIdentityFact(input.manifest, posture, totals, input.fieldIdentityTotals),
+  ];
+
+  return {
+    schemaVersion: "l06-redline-posture-calibration/v0",
+    facts,
+    summary: {
+      ...totals,
+      posture,
+      downstreamRouteCount: new Set(facts.flatMap((fact) => fact.downstreamRoutes)).size,
+      l04ActionableFieldRows: input.fieldIdentityTotals?.actionableL04 ?? 0,
+      ownsGeometry: false,
+      ownsVisualPaint: false,
+    },
+  };
+}
+
+function buildAllMarkupPostureFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+): WorkflowRedlinePostureFact {
+  return {
+    factId: "all-markup-review-posture",
+    representation: "durable-workflow-review-posture",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: [
+      "WorkflowMarkupModePolicy",
+      "WorkflowMarkupSnapshot.revisions",
+      "TrackedChangesSnapshot.revisions",
+    ],
+    downstreamRoutes: ["L04 redline measurement posture", "L11 redline overlay paint"],
+    evidence: {
+      documents: totals.documentCount,
+      availableDocuments: totals.availableDocumentCount,
+      wordVersion: manifest.targetedWord?.version ?? "unknown",
+      wordBuild: manifest.targetedWord?.build ?? "unknown",
+    },
+    note:
+      "The redline Word JSON dataset is captured in all-markup posture; L06 names that durable review posture before layout or paint consume it.",
+  };
+}
+
+function buildReviewCountFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+): WorkflowRedlinePostureFact {
+  return {
+    factId: "revision-comment-counts",
+    representation: "durable-workflow-review-posture",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: [
+      "WorkflowMarkupSnapshot.revisions",
+      "WorkflowMarkupSnapshot.comments",
+      "TrackedChangesSnapshot.revisions",
+      "CommentSidebarSnapshot.threads",
+    ],
+    downstreamRoutes: ["L11 review/comment lane visibility", "L08 comment/revision scope posture"],
+    evidence: {
+      revisions: totals.revisionCount,
+      comments: totals.commentCount,
+      documentsWithReviewData: totals.availableDocumentCount,
+    },
+    note:
+      "Revision and comment totals are L06 review-store facts; geometry and balloon placement stay with downstream consumers.",
+  };
+}
+
+function buildMeasurementHandoffFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+): WorkflowRedlinePostureFact {
+  return {
+    factId: "clean-all-markup-measurement-handoff",
+    representation: "measurement-handoff",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: ["EffectiveLayoutFormatting.revisionPosture", "WorkflowMarkupModePolicy"],
+    downstreamRoutes: ["L04 clean-vs-all-markup page/frame delta", "L11 render-word assertion planning"],
+    evidence: {
+      pagesInAllMarkupPosture: totals.pageCount,
+      uiaLinesInAllMarkupPosture: totals.uiaLineCount,
+      ownsGeometry: false,
+    },
+    note:
+      "L06 names the measurement-affecting review posture; L04 owns page/frame deltas and L11 owns visual assertion planning.",
+  };
+}
+
+function buildFieldIdentityFact(
+  manifest: WorkflowRedlineDatasetManifestLike,
+  posture: WorkflowRedlinePosture,
+  totals: WorkflowRedlinePostureTotals,
+  fieldIdentityTotals: WorkflowRedlineFieldIdentityTotalsLike | undefined,
+): WorkflowRedlinePostureFact {
+  const actionableRows = fieldIdentityTotals?.actionableL04 ?? 0;
+  return {
+    factId: "redline-field-identity-posture",
+    representation: actionableRows > 0 ? "field-region-posture-handoff" : "blocked-until-identity-join",
+    posture,
+    sourceRun: manifest.sourceRun,
+    l06Surfaces: ["WorkflowMarkupModePolicy", "WorkflowMarkupSnapshot.fields"],
+    downstreamRoutes: [
+      "L01 source field identity",
+      "L02 canonical field identity",
+      "L04 redline field-region measurement",
+    ],
+    evidence: {
+      redlineWordFields: fieldIdentityTotals?.wordFields ?? totals.fieldCount,
+      sourceJoinedRows: fieldIdentityTotals?.joined ?? 0,
+      missingSourceField: fieldIdentityTotals?.missingSourceField ?? 0,
+      missingCanonicalField: fieldIdentityTotals?.missingCanonicalField ?? 0,
+      missingRuntimeRegion: fieldIdentityTotals?.missingRuntimeRegion ?? 0,
+      actionableL04: actionableRows,
+    },
+    note:
+      actionableRows > 0
+        ? "L06 review posture is named and the field rows may proceed to L04 with identity joins present."
+        : "L06 review posture is named as all-markup, but redline field-region rows remain blocked on source/canonical/runtime identity joins.",
+  };
+}
+
+function resolvePosture(markupModes: readonly string[] | undefined): WorkflowRedlinePosture {
+  if (!markupModes || markupModes.length !== 1) return "unknown";
+  switch (markupModes[0]) {
+    case "all":
+    case "all-markup":
+      return "all-markup";
+    case "final":
+      return "final";
+    case "original":
+      return "original";
+    default:
+      return "unknown";
+  }
+}
+
+function sum<T>(items: readonly T[], selector: (item: T) => number): number {
+  return items.reduce((total, item) => total + selector(item), 0);
+}