@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/validation/docx-comment-proof.ts

@@ -1,707 +0,0 @@
-import type {
-  CompatibilityReport,
-  DocumentNavigationSnapshot,
-  FieldSnapshot,
-  ProtectionSnapshot,
-  RuntimeRenderSnapshot,
-} from "../api/public-types.ts";
-import { parseCommentsFromOoxml } from "../io/ooxml/parse-comments.ts";
-import { readOpcPackage } from "../io/opc/package-reader.ts";
-
-export interface ClosureValidationContext {
-  renderSnapshot: Pick<
-    RuntimeRenderSnapshot,
-    | "isReady"
-    | "fatalError"
-    | "comments"
-    | "trackedChanges"
-    | "surface"
-    | "pageLayout"
-  >;
-  navigation?: Pick<DocumentNavigationSnapshot, "pages">;
-  compatibility: Pick<CompatibilityReport, "errors" | "featureEntries">;
-  surface: RuntimeRenderSnapshot["surface"];
-  fieldSnapshot?: FieldSnapshot;
-  protectionSnapshot?: ProtectionSnapshot;
-  harnessShowcase?: HarnessShowcaseValidationContext;
-}
-
-export type HarnessShowcaseArea =
-  | "workflow-overlay"
-  | "blocked-commands"
-  | "preserve-only"
-  | "search-candidates"
-  | "right-rail"
-  | "multi-scope"
-  | "public-api"
-  | "sidebar-integration"
-  | "policy-yaml"
-  | "harness-lifecycle"
-  | "export-continuity";
-
-export interface HarnessShowcaseAreaProof {
-  demonstrated: boolean;
-  detail?: string;
-  proofArtifacts?: string[];
-}
-
-export interface HarnessShowcaseValidationContext {
-  areas: Partial<Record<HarnessShowcaseArea, HarnessShowcaseAreaProof>>;
-}
-
-export type ClosureValidationCheck =
-  | { type: "mustLoad" }
-  | { type: "compatibilityFeature"; featureKey: string; featureClass: string }
-  | { type: "minTrackedChanges"; count: number }
-  | { type: "maxTrackedChanges"; count: number }
-  | { type: "minCommentThreads"; count: number }
-  | { type: "lockedFragmentCountAtLeast"; count: number }
-  | { type: "surfaceBlockKind"; kind: string; count?: number }
-  | { type: "opaqueBlockLabelPrefix"; value: string }
-  | { type: "opaqueInlineLabelPrefix"; value: string }
-  | {
-      type: "trackedChangeMatch";
-      kind?: "insertion" | "deletion" | "formatting" | "move" | "property-change";
-      actionability?: "actionable" | "preserve-only";
-      status?: "active" | "accepted" | "rejected" | "detached";
-      preserveOnlyReasonIncludes?: string[];
-    }
-  | {
-      type: "fieldEntryMatch";
-      fieldFamily?: string;
-      supported?: boolean;
-      refreshStatus?: string;
-      displayTextIncludes?: string[];
-      fieldTarget?: string;
-    }
-  | {
-      type: "protectionMatch";
-      hasDocumentProtection?: boolean;
-      editType?: string;
-      enforcementActive?: boolean;
-      enforcedRangeCountAtLeast?: number;
-      preservedRangeCountAtLeast?: number;
-      rangeId?: string;
-      rangeEnforced?: boolean;
-    }
-  | {
-      type: "secondaryStoryMatch";
-      kind: "header" | "footer" | "footnote" | "endnote";
-      relationshipId?: string;
-      variant?: "default" | "first" | "even";
-      noteId?: string;
-      minBlockCount?: number;
-    }
-  | {
-      type: "pageLayoutMatch";
-      sectionIndex?: number;
-      orientation?: "portrait" | "landscape";
-      columns?: number;
-      differentFirstPage?: boolean;
-      differentOddEvenPages?: boolean;
-      headerVariantCountAtLeast?: number;
-      footerVariantCountAtLeast?: number;
-    }
-  | {
-      type: "commentThreadMatch";
-      commentId?: string;
-      status?: "open" | "resolved" | "detached";
-      entryCount?: number;
-      anchorKind?: "range" | "node" | "detached";
-      bodyIncludes?: string[];
-      entryBodies?: string[];
-      entryAuthorIds?: string[];
-      authorId?: string;
-    }
-  | {
-      type: "harnessShowcase";
-      area: HarnessShowcaseArea;
-      claim: string;
-    };
-
-export interface ClosureValidationResult {
-  type: string;
-  passed: boolean;
-  reason: string;
-}
-
-export interface DocxCommentProof {
-  partPresence: {
-    commentsXml: boolean;
-    commentsExtendedXml: boolean;
-    commentsIdsXml: boolean;
-    peopleXml: boolean;
-  };
-  serializedCommentIds: string[];
-  peopleAuthors: string[];
-  threads: Array<{
-    commentId: string;
-    rootCommentId?: string;
-    status: "open" | "resolved" | "detached";
-    entryCount: number;
-    bodies: string[];
-    authorIds: string[];
-    anchorKind: "range" | "node" | "detached";
-  }>;
-}
-
-export function evaluateHarnessShowcaseCheck(
-  check: Extract<ClosureValidationCheck, { type: "harnessShowcase" }>,
-  context: HarnessShowcaseValidationContext,
-): ClosureValidationResult {
-  const areaProof = context.areas[check.area];
-  if (!areaProof) {
-    return {
-      type: check.type,
-      passed: false,
-      reason: `missing harness showcase proof for area ${check.area}: ${check.claim}`,
-    };
-  }
-
-  return {
-    type: check.type,
-    passed: areaProof.demonstrated,
-    reason:
-      areaProof.detail ??
-      `expected harness showcase proof for area ${check.area}: ${check.claim}`,
-  };
-}
-
-export function evaluateClosureCheck(
-  check: ClosureValidationCheck,
-  context: ClosureValidationContext,
-): ClosureValidationResult {
-  switch (check.type) {
-    case "mustLoad":
-      return {
-        type: check.type,
-        passed:
-          context.renderSnapshot.isReady &&
-          context.renderSnapshot.fatalError === undefined &&
-          context.compatibility.errors.length === 0,
-        reason: "exported artifact did not reload into a healthy runtime",
-      };
-    case "compatibilityFeature": {
-      const passed = context.compatibility.featureEntries.some(
-        (entry) =>
-          entry.featureKey === check.featureKey &&
-          entry.featureClass === check.featureClass,
-      );
-      return {
-        type: check.type,
-        passed,
-        reason: `missing compatibility feature ${check.featureKey}:${check.featureClass}`,
-      };
-    }
-    case "minTrackedChanges":
-      return {
-        type: check.type,
-        passed: context.renderSnapshot.trackedChanges.totalCount >= check.count,
-        reason: `expected at least ${check.count} tracked changes`,
-      };
-    case "maxTrackedChanges":
-      return {
-        type: check.type,
-        passed: context.renderSnapshot.trackedChanges.totalCount <= check.count,
-        reason: `expected at most ${check.count} tracked changes`,
-      };
-    case "minCommentThreads":
-      return {
-        type: check.type,
-        passed: context.renderSnapshot.comments.totalCount >= check.count,
-        reason: `expected at least ${check.count} comment threads`,
-      };
-    case "lockedFragmentCountAtLeast":
-      return {
-        type: check.type,
-        passed: (context.surface?.lockedFragmentIds.length ?? 0) >= check.count,
-        reason: `expected at least ${check.count} locked fragments`,
-      };
-    case "surfaceBlockKind":
-      return {
-        type: check.type,
-        passed:
-          (context.surface?.blocks.filter((block) => block.kind === check.kind).length ?? 0) >=
-          (check.count ?? 1),
-        reason: `expected at least ${check.count ?? 1} surface blocks of kind ${check.kind}`,
-      };
-    case "opaqueBlockLabelPrefix":
-      return {
-        type: check.type,
-        passed:
-          context.surface?.blocks.some(
-            (block) =>
-              block.kind === "opaque_block" &&
-              typeof block.label === "string" &&
-              block.label.startsWith(check.value),
-          ) ?? false,
-        reason: `expected an opaque block label starting with ${check.value}`,
-      };
-    case "opaqueInlineLabelPrefix":
-      return {
-        type: check.type,
-        passed: hasOpaqueInlineLabelPrefix(context.surface, check.value),
-        reason: `expected an opaque inline label starting with ${check.value}`,
-      };
-    case "trackedChangeMatch": {
-      const passed = context.renderSnapshot.trackedChanges.revisions.some((revision) => {
-        if (check.kind && revision.kind !== check.kind) {
-          return false;
-        }
-        if (check.actionability && revision.actionability !== check.actionability) {
-          return false;
-        }
-        if (check.status && revision.status !== check.status) {
-          return false;
-        }
-        if (
-          check.preserveOnlyReasonIncludes &&
-          !check.preserveOnlyReasonIncludes.every((fragment) =>
-            (revision.preserveOnlyReason ?? "").includes(fragment),
-          )
-        ) {
-          return false;
-        }
-        return true;
-      });
-      return {
-        type: check.type,
-        passed,
-        reason: `expected a tracked change matching ${describeTrackedChangeMatch(check)}`,
-      };
-    }
-    case "fieldEntryMatch": {
-      const passed =
-        context.fieldSnapshot?.fields.some((field) => {
-          if (check.fieldFamily && field.fieldFamily !== check.fieldFamily) {
-            return false;
-          }
-          if (check.supported !== undefined && field.supported !== check.supported) {
-            return false;
-          }
-          if (check.refreshStatus && field.refreshStatus !== check.refreshStatus) {
-            return false;
-          }
-          if (check.fieldTarget && field.fieldTarget !== check.fieldTarget) {
-            return false;
-          }
-          if (
-            check.displayTextIncludes &&
-            !check.displayTextIncludes.every((fragment) => field.displayText.includes(fragment))
-          ) {
-            return false;
-          }
-          return true;
-        }) ?? false;
-      return {
-        type: check.type,
-        passed,
-        reason: `expected a field entry matching ${describeFieldEntryMatch(check)}`,
-      };
-    }
-    case "protectionMatch": {
-      const snapshot = context.protectionSnapshot;
-      const passed = Boolean(
-        snapshot &&
-          (check.hasDocumentProtection === undefined ||
-            snapshot.hasDocumentProtection === check.hasDocumentProtection) &&
-          (check.editType === undefined || snapshot.editType === check.editType) &&
-          (check.enforcementActive === undefined ||
-            snapshot.enforcementActive === check.enforcementActive) &&
-          (check.enforcedRangeCountAtLeast === undefined ||
-            snapshot.enforcedRangeCount >= check.enforcedRangeCountAtLeast) &&
-          (check.preservedRangeCountAtLeast === undefined ||
-            snapshot.preservedRangeCount >= check.preservedRangeCountAtLeast) &&
-          (!check.rangeId ||
-            snapshot.ranges.some((range) =>
-              range.rangeId === check.rangeId &&
-              (check.rangeEnforced === undefined || range.enforced === check.rangeEnforced),
-            ))
-      );
-      return {
-        type: check.type,
-        passed,
-        reason: `expected protection snapshot matching ${describeProtectionMatch(check)}`,
-      };
-    }
-    case "secondaryStoryMatch": {
-      const passed =
-        context.surface?.secondaryStories.some((story) => {
-          if (story.target.kind !== check.kind) {
-            return false;
-          }
-          if (
-            "relationshipId" in story.target &&
-            check.relationshipId &&
-            story.target.relationshipId !== check.relationshipId
-          ) {
-            return false;
-          }
-          if ("variant" in story.target && check.variant && story.target.variant !== check.variant) {
-            return false;
-          }
-          if ("noteId" in story.target && check.noteId && story.target.noteId !== check.noteId) {
-            return false;
-          }
-          if ((check.minBlockCount ?? 0) > story.blocks.length) {
-            return false;
-          }
-          return true;
-        }) ?? false;
-      return {
-        type: check.type,
-        passed,
-        reason: `expected secondary story ${describeSecondaryStoryMatch(check)}`,
-      };
-    }
-    case "pageLayoutMatch": {
-      const layouts = getLayoutsForCheck(context, check);
-      const headerVariantCount = countUniqueStoryVariants(layouts, "headerVariants");
-      const footerVariantCount = countUniqueStoryVariants(layouts, "footerVariants");
-      const passed = Boolean(
-        layouts.length > 0 &&
-          layouts.some(
-            (layout) =>
-              (check.orientation === undefined || layout.orientation === check.orientation) &&
-              (check.columns === undefined || layout.columns === check.columns) &&
-              (check.differentFirstPage === undefined ||
-                layout.differentFirstPage === check.differentFirstPage) &&
-              (check.differentOddEvenPages === undefined ||
-                layout.differentOddEvenPages === check.differentOddEvenPages),
-          ) &&
-          (check.headerVariantCountAtLeast === undefined ||
-            headerVariantCount >= check.headerVariantCountAtLeast) &&
-          (check.footerVariantCountAtLeast === undefined ||
-            footerVariantCount >= check.footerVariantCountAtLeast)
-      );
-      return {
-        type: check.type,
-        passed,
-        reason: `expected page layout ${describePageLayoutMatch(check)}`,
-      };
-    }
-    case "commentThreadMatch": {
-      const passed = context.renderSnapshot.comments.threads.some((thread) =>
-        matchesCommentThread(thread, check),
-      );
-      return {
-        type: check.type,
-        passed,
-        reason: `expected a comment thread matching ${describeCommentThreadMatch(check)}`,
-      };
-    }
-    case "harnessShowcase":
-      return evaluateHarnessShowcaseCheck(check, context.harnessShowcase ?? { areas: {} });
-    default:
-      return {
-        type: (check as { type: string }).type,
-        passed: false,
-        reason: `unknown closure validation check type ${(check as { type: string }).type}`,
-      };
-  }
-}
-
-export function extractDocxCommentProof(bytes: Uint8Array): DocxCommentProof {
-  const packageFile = readOpcPackage(bytes);
-  const documentXml = decodePartText(packageFile.parts.get("/word/document.xml")?.bytes);
-  const commentsXml = decodePartText(packageFile.parts.get("/word/comments.xml")?.bytes);
-  const commentsExtendedXml = decodePartText(
-    packageFile.parts.get("/word/commentsExtended.xml")?.bytes,
-  );
-  const commentsIdsXml = decodePartText(packageFile.parts.get("/word/commentsIds.xml")?.bytes);
-  const peopleXml = decodePartText(packageFile.parts.get("/word/people.xml")?.bytes);
-  const parsedComments =
-    documentXml && commentsXml
-      ? parseCommentsFromOoxml(documentXml, {
-          commentsXml,
-          commentsExtendedXml,
-          commentsIdsXml,
-          peopleXml,
-        })
-      : {
-          threads: [],
-          definitions: [],
-          peopleAuthors: [],
-        };
-
-  return {
-    partPresence: {
-      commentsXml: commentsXml.length > 0,
-      commentsExtendedXml: commentsExtendedXml.length > 0,
-      commentsIdsXml: commentsIdsXml.length > 0,
-      peopleXml: peopleXml.length > 0,
-    },
-    serializedCommentIds: parsedComments.definitions.map((definition) => definition.commentId),
-    peopleAuthors: [...parsedComments.peopleAuthors],
-    threads: parsedComments.threads.map((thread) => ({
-      commentId: thread.commentId,
-      rootCommentId: thread.metadata?.rootOoxmlCommentId,
-      status: thread.status,
-      entryCount: thread.entries.length,
-      bodies: thread.entries.map((entry) => entry.body),
-      authorIds: [...new Set(thread.entries.map((entry) => entry.authorId))],
-      anchorKind: thread.anchor.kind,
-    })),
-  };
-}
-
-function hasOpaqueInlineLabelPrefix(
-  surface: RuntimeRenderSnapshot["surface"],
-  prefix: string,
-): boolean {
-  if (!surface) {
-    return false;
-  }
-
-  for (const block of surface.blocks) {
-    if (block.kind !== "paragraph") {
-      continue;
-    }
-
-    if (
-      block.segments.some(
-        (segment) =>
-          segment.kind === "opaque_inline" &&
-          typeof segment.label === "string" &&
-          segment.label.startsWith(prefix),
-      )
-    ) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function matchesCommentThread(
-  thread: RuntimeRenderSnapshot["comments"]["threads"][number],
-  check: Extract<ClosureValidationCheck, { type: "commentThreadMatch" }>,
-): boolean {
-  if (check.commentId && thread.commentId !== check.commentId) {
-    return false;
-  }
-  if (check.status && thread.status !== check.status) {
-    return false;
-  }
-  if (typeof check.entryCount === "number" && thread.entries.length !== check.entryCount) {
-    return false;
-  }
-  if (check.anchorKind && thread.anchor.kind !== check.anchorKind) {
-    return false;
-  }
-  if (check.authorId && thread.createdBy !== check.authorId) {
-    return false;
-  }
-  if (check.bodyIncludes?.length) {
-    const bodies = thread.entries.map((entry) => entry.body);
-    for (const expectedBody of check.bodyIncludes) {
-      if (!bodies.some((body) => body.includes(expectedBody))) {
-        return false;
-      }
-    }
-  }
-  if (check.entryBodies?.length) {
-    if (thread.entries.length < check.entryBodies.length) {
-      return false;
-    }
-    for (let index = 0; index < check.entryBodies.length; index += 1) {
-      const expectedBody = check.entryBodies[index];
-      const actualBody = thread.entries[index]?.body;
-      if (typeof expectedBody !== "string" || actualBody !== expectedBody) {
-        return false;
-      }
-    }
-  }
-  if (check.entryAuthorIds?.length) {
-    if (thread.entries.length < check.entryAuthorIds.length) {
-      return false;
-    }
-    for (let index = 0; index < check.entryAuthorIds.length; index += 1) {
-      const expectedAuthorId = check.entryAuthorIds[index];
-      const actualAuthorId = thread.entries[index]?.authorId;
-      if (typeof expectedAuthorId !== "string" || actualAuthorId !== expectedAuthorId) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-function describeTrackedChangeMatch(
-  check: Extract<ClosureValidationCheck, { type: "trackedChangeMatch" }>,
-): string {
-  return [
-    check.kind ? `kind=${check.kind}` : undefined,
-    check.actionability ? `actionability=${check.actionability}` : undefined,
-    check.status ? `status=${check.status}` : undefined,
-    check.preserveOnlyReasonIncludes?.length
-      ? `preserveOnlyReasonIncludes=${check.preserveOnlyReasonIncludes.join(",")}`
-      : undefined,
-  ]
-    .filter(Boolean)
-    .join(" ");
-}
-
-function describeFieldEntryMatch(
-  check: Extract<ClosureValidationCheck, { type: "fieldEntryMatch" }>,
-): string {
-  return [
-    check.fieldFamily ? `fieldFamily=${check.fieldFamily}` : undefined,
-    check.supported !== undefined ? `supported=${String(check.supported)}` : undefined,
-    check.refreshStatus ? `refreshStatus=${check.refreshStatus}` : undefined,
-    check.fieldTarget ? `fieldTarget=${check.fieldTarget}` : undefined,
-    check.displayTextIncludes?.length
-      ? `displayTextIncludes=${check.displayTextIncludes.join(",")}`
-      : undefined,
-  ]
-    .filter(Boolean)
-    .join(" ");
-}
-
-function describeProtectionMatch(
-  check: Extract<ClosureValidationCheck, { type: "protectionMatch" }>,
-): string {
-  return [
-    check.hasDocumentProtection !== undefined
-      ? `hasDocumentProtection=${String(check.hasDocumentProtection)}`
-      : undefined,
-    check.editType ? `editType=${check.editType}` : undefined,
-    check.enforcementActive !== undefined
-      ? `enforcementActive=${String(check.enforcementActive)}`
-      : undefined,
-    check.enforcedRangeCountAtLeast !== undefined
-      ? `enforcedRangeCountAtLeast=${String(check.enforcedRangeCountAtLeast)}`
-      : undefined,
-    check.preservedRangeCountAtLeast !== undefined
-      ? `preservedRangeCountAtLeast=${String(check.preservedRangeCountAtLeast)}`
-      : undefined,
-    check.rangeId ? `rangeId=${check.rangeId}` : undefined,
-    check.rangeEnforced !== undefined
-      ? `rangeEnforced=${String(check.rangeEnforced)}`
-      : undefined,
-  ]
-    .filter(Boolean)
-    .join(" ");
-}
-
-function getLayoutsForCheck(
-  context: ClosureValidationContext,
-  check: Extract<ClosureValidationCheck, { type: "pageLayoutMatch" }>,
-) {
-  const navigationLayouts =
-    context.navigation?.pages
-      .filter((page) => check.sectionIndex === undefined || page.sectionIndex === check.sectionIndex)
-      .map((page) => page.layout) ?? [];
-  if (navigationLayouts.length > 0) {
-    return navigationLayouts;
-  }
-  const activeLayout = context.renderSnapshot.pageLayout;
-  if (
-    activeLayout &&
-    (check.sectionIndex === undefined || activeLayout.sectionIndex === check.sectionIndex)
-  ) {
-    return [activeLayout];
-  }
-  return [];
-}
-
-function countUniqueStoryVariants(
-  layouts: Array<{
-    headerVariants: Array<{ variant: string; relationshipId: string }>;
-    footerVariants: Array<{ variant: string; relationshipId: string }>;
-  }>,
-  key: "headerVariants" | "footerVariants",
-) {
-  const variants = new Set<string>();
-  for (const layout of layouts) {
-    for (const variant of layout[key]) {
-      variants.add(`${variant.variant}:${variant.relationshipId}`);
-    }
-  }
-  return variants.size;
-}
-
-function describeCommentThreadMatch(
-  check: Extract<ClosureValidationCheck, { type: "commentThreadMatch" }>,
-): string {
-  const parts: string[] = [];
-  if (check.commentId) {
-    parts.push(`commentId=${check.commentId}`);
-  }
-  if (check.status) {
-    parts.push(`status=${check.status}`);
-  }
-  if (typeof check.entryCount === "number") {
-    parts.push(`entryCount=${check.entryCount}`);
-  }
-  if (check.anchorKind) {
-    parts.push(`anchorKind=${check.anchorKind}`);
-  }
-  if (check.authorId) {
-    parts.push(`authorId=${check.authorId}`);
-  }
-  if (check.bodyIncludes?.length) {
-    parts.push(`bodyIncludes=${check.bodyIncludes.join(" | ")}`);
-  }
-  if (check.entryBodies?.length) {
-    parts.push(`entryBodies=${check.entryBodies.join(" | ")}`);
-  }
-  if (check.entryAuthorIds?.length) {
-    parts.push(`entryAuthorIds=${check.entryAuthorIds.join(" | ")}`);
-  }
-  return parts.length > 0 ? parts.join(", ") : "any thread";
-}
-
-function describeSecondaryStoryMatch(
-  check: Extract<ClosureValidationCheck, { type: "secondaryStoryMatch" }>,
-): string {
-  const parts = [`kind=${check.kind}`];
-  if (check.relationshipId) {
-    parts.push(`relationshipId=${check.relationshipId}`);
-  }
-  if (check.variant) {
-    parts.push(`variant=${check.variant}`);
-  }
-  if (check.noteId) {
-    parts.push(`noteId=${check.noteId}`);
-  }
-  if (typeof check.minBlockCount === "number") {
-    parts.push(`minBlockCount=${check.minBlockCount}`);
-  }
-  return parts.join(", ");
-}
-
-function describePageLayoutMatch(
-  check: Extract<ClosureValidationCheck, { type: "pageLayoutMatch" }>,
-): string {
-  const parts: string[] = [];
-  if (typeof check.sectionIndex === "number") {
-    parts.push(`sectionIndex=${check.sectionIndex}`);
-  }
-  if (check.orientation) {
-    parts.push(`orientation=${check.orientation}`);
-  }
-  if (typeof check.columns === "number") {
-    parts.push(`columns=${check.columns}`);
-  }
-  if (typeof check.differentFirstPage === "boolean") {
-    parts.push(`differentFirstPage=${check.differentFirstPage}`);
-  }
-  if (typeof check.differentOddEvenPages === "boolean") {
-    parts.push(`differentOddEvenPages=${check.differentOddEvenPages}`);
-  }
-  if (typeof check.headerVariantCountAtLeast === "number") {
-    parts.push(`headerVariantCountAtLeast=${check.headerVariantCountAtLeast}`);
-  }
-  if (typeof check.footerVariantCountAtLeast === "number") {
-    parts.push(`footerVariantCountAtLeast=${check.footerVariantCountAtLeast}`);
-  }
-  return parts.length > 0 ? parts.join(", ") : "present";
-}
-
-function decodePartText(bytes: Uint8Array | undefined): string {
-  if (!bytes) {
-    return "";
-  }
-  return new TextDecoder("utf-8").decode(bytes);
-}