@pixel-point/toolcraft 0.0.16 → 0.0.18

package/templates/runtime/react/app-shell/toolcraft-source-asset-context.tsx

@@ -1,28 +1,14 @@
-/// <reference types="vite/client" />
-
 "use client";
 
 import * as React from "react";
 
-import {
-  createToolcraftSourceAssetCoordinator,
-  type ToolcraftSourceAssetCoordinator,
-} from "../../source-assets/source-asset-coordinator";
-import { createIndexedDbToolcraftBinaryAssetRepository } from "../../source-assets/repository/indexeddb-binary-asset-repository";
-import { createMemoryToolcraftBinaryAssetRepository } from "../../source-assets/repository/memory-binary-asset-repository";
-import { createUnavailableToolcraftBinaryAssetRepository } from "../../source-assets/repository/unavailable-binary-asset-repository";
-import type { ToolcraftBinaryAssetRepository } from "../../source-assets/repository/binary-asset-repository";
-import {
-  createToolcraftSourceAssetPresentationResources,
-  type ToolcraftSourceAssetPresentationResources,
-} from "../../source-assets/source-asset-presentation-resources";
 import {
   createToolcraftDefaultBinaryMediaHydrationJobs,
   getToolcraftBinaryMediaHydrationKey,
   type ToolcraftBinaryMediaHydrationJob,
 } from "../../source-assets/binary-media-hydration";
+import type { ToolcraftSourceAssetCoordinator } from "../../source-assets/source-asset-coordinator";
 import type { ToolcraftExternalStore } from "../../state/toolcraft-external-store";
-import type { ToolcraftImageAsset } from "../../state/types";
 import { ToolcraftModelRenderProvider } from "../model-rendering/model-render-provider";
 import { useToolcraftModelPresentationMode } from "../model-rendering/model-presentation-mode";
 import {
@@ -30,6 +16,8 @@ import {
   resolveToolcraftOrientationControl,
 } from "../orientation-gizmo/orientation-gizmo-selection";
 import { ToolcraftMediaPresentationProvider } from "./toolcraft-media-presentation";
+import { acquireToolcraftSourceAssetOwner } from "./toolcraft-source-asset-owner";
+import { decorateToolcraftUnavailableResourceProofCoordinator } from "./toolcraft-unavailable-resource-proof";
 
 export { useToolcraftMediaPresentationUrls } from "./toolcraft-media-presentation";
 
@@ -40,33 +28,13 @@ type ToolcraftSourceAssetCoordinatorFactory = (
   store: ToolcraftExternalStore,
 ) => ToolcraftSourceAssetCoordinator;
 
-type ToolcraftSourceAssetOwner = {
-  activeUnavailableResourceProof: {
-    assetId: string;
-    requestId: string;
-    resourceRef: string;
-  } | null;
-  coordinator: ToolcraftSourceAssetCoordinator;
-  lifecycleGeneration: number;
-  onDisposeError: (error: unknown) => void;
-  presentationResources: ToolcraftSourceAssetPresentationResources | null;
-  unavailableResourceProofRefs: Set<string>;
-};
+type ToolcraftSourceAssetOwnerLease = ReturnType<
+  typeof acquireToolcraftSourceAssetOwner
+>;
 
-const TOOLCRAFT_UNAVAILABLE_RESOURCE_PROOF_REQUEST =
-  "toolcraft.browser-proof.unavailable-resource-request";
-const TOOLCRAFT_UNAVAILABLE_RESOURCE_PROOF_ATTRIBUTE =
-  "data-toolcraft-unavailable-resource-evidence";
-const toolcraftUnavailableResourceProofEnabled =
-  import.meta.env?.MODE === "test" ||
-  import.meta.env?.VITE_TOOLCRAFT_BROWSER_PROOF_FIXTURES ===
-    "unavailable-resource";
-
-type ToolcraftUnavailableResourceProofRequest = Readonly<{
-  action: "activate" | "cleanup";
-  fileName: string;
-  requestId: string;
-  sourceTarget?: string;
+type ToolcraftSourceAssetAcquisition = Readonly<{
+  lease: ToolcraftSourceAssetOwnerLease;
+  store: ToolcraftExternalStore;
 }>;
 
 function selectModelHydrationFingerprint(
@@ -94,166 +62,71 @@ function selectBinaryHydrationFingerprint(
     .join("\u0001");
 }
 
-const sourceAssetOwners = new WeakMap<
-  ToolcraftExternalStore,
-  ToolcraftSourceAssetOwner
->();
-
-function createRepository(): ToolcraftBinaryAssetRepository {
-  if (typeof globalThis.indexedDB === "undefined") {
-    return typeof navigator !== "undefined" &&
-      navigator.userAgent.toLowerCase().includes("jsdom")
-      ? createMemoryToolcraftBinaryAssetRepository()
-      : createUnavailableToolcraftBinaryAssetRepository();
-  }
-
-  try {
-    return createIndexedDbToolcraftBinaryAssetRepository();
-  } catch {
-    return createUnavailableToolcraftBinaryAssetRepository();
-  }
-}
-
-function reportSourceAssetDisposeError(error: unknown): void {
-  const globalReportError = globalThis.reportError;
-  if (typeof globalReportError === "function") {
-    try {
-      globalReportError(error);
-      return;
-    } catch (reportingFailure) {
-      console.error(
-        "Toolcraft source asset disposal reporting failed.",
-        new AggregateError(
-          [error, reportingFailure],
-          "Toolcraft source asset disposal and reporting both failed.",
-        ),
-      );
-      return;
-    }
-  }
-  console.error("Toolcraft source asset disposal failed.", error);
-}
-
-const createDefaultCoordinator: ToolcraftSourceAssetCoordinatorFactory = (
-  store,
-) =>
-  createToolcraftSourceAssetCoordinator({
-    dispatch: store.dispatch,
-    getState: store.getCommittedState,
-    repository: createRepository(),
-  });
-
-function getOrCreateSourceAssetOwner(
-  store: ToolcraftExternalStore,
-  createCoordinator: ToolcraftSourceAssetCoordinatorFactory,
-  onDisposeError: (error: unknown) => void,
-): ToolcraftSourceAssetOwner {
-  const current = sourceAssetOwners.get(store);
-  if (current) return current;
-
-  const baseCoordinator = createCoordinator(store);
-  const unavailableResourceProofRefs = new Set<string>();
-  const proofScopedResolveResource = baseCoordinator.resolveResource
-    ? async (
-        ref: string,
-        options: Readonly<{ signal: AbortSignal }>,
-      ): Promise<Uint8Array | null> =>
-        unavailableResourceProofRefs.has(ref)
-          ? null
-          : baseCoordinator.resolveResource!(ref, options)
-    : undefined;
-  const coordinator = proofScopedResolveResource
-    ? {
-        ...baseCoordinator,
-        resolveResource: proofScopedResolveResource,
-      }
-    : baseCoordinator;
-  const presentationResources =
-    coordinator.resolveResource && coordinator.retainResourceRef
-      ? createToolcraftSourceAssetPresentationResources({
-          resolveResource: coordinator.resolveResource,
-          retainResourceRef: coordinator.retainResourceRef,
-        })
-      : null;
-  const owner = {
-    activeUnavailableResourceProof: null,
-    coordinator,
-    lifecycleGeneration: 0,
-    onDisposeError,
-    presentationResources,
-    unavailableResourceProofRefs,
-  };
-  sourceAssetOwners.set(store, owner);
-  return owner;
-}
-
-function readUnavailableResourceProofRequest(
-  event: Event,
-): ToolcraftUnavailableResourceProofRequest | null {
-  if (!(event instanceof CustomEvent)) return null;
-  const detail: unknown = event.detail;
-  if (typeof detail !== "object" || detail === null || Array.isArray(detail)) {
-    return null;
-  }
-
-  const request = detail as Partial<ToolcraftUnavailableResourceProofRequest>;
-  if (
-    (request.action !== "activate" && request.action !== "cleanup") ||
-    typeof request.fileName !== "string" ||
-    request.fileName.trim() !== request.fileName ||
-    request.fileName.length === 0 ||
-    typeof request.requestId !== "string" ||
-    request.requestId.trim() !== request.requestId ||
-    request.requestId.length === 0 ||
-    (
-      request.sourceTarget !== undefined &&
-      (
-        typeof request.sourceTarget !== "string" ||
-        request.sourceTarget.trim() !== request.sourceTarget ||
-        request.sourceTarget.length === 0
-      )
-    )
-  ) {
-    return null;
-  }
-
-  return request as ToolcraftUnavailableResourceProofRequest;
-}
-
-function reportOwnerDisposeError(
-  owner: ToolcraftSourceAssetOwner,
-  error: unknown,
-): void {
-  try {
-    owner.onDisposeError(error);
-  } catch (reportingFailure) {
-    reportSourceAssetDisposeError(
-      new AggregateError(
-        [error, reportingFailure],
-        "Toolcraft source asset disposal and its injected reporter both failed.",
-      ),
-    );
-  }
-}
-
 export function ToolcraftSourceAssetProvider({
   binaryMediaHydrationJobs = [],
   children,
-  createCoordinator = createDefaultCoordinator,
-  onDisposeError = reportSourceAssetDisposeError,
+  createCoordinator,
+  onDisposeError,
+  onError,
   store,
 }: {
   binaryMediaHydrationJobs?: readonly ToolcraftBinaryMediaHydrationJob[];
   children: React.ReactNode;
   createCoordinator?: ToolcraftSourceAssetCoordinatorFactory;
+  /** @deprecated Use onError. */
   onDisposeError?: (error: unknown) => void;
+  onError?: (error: unknown) => void;
   store: ToolcraftExternalStore;
 }): React.JSX.Element {
-  const owner = getOrCreateSourceAssetOwner(
-    store,
-    createCoordinator,
-    onDisposeError,
-  );
+  const [acquisition, setAcquisition] =
+    React.useState<ToolcraftSourceAssetAcquisition | null>(null);
+  const activeLease = acquisition?.store === store
+    ? acquisition.lease
+    : null;
+  const constructionOnError = onError ?? onDisposeError;
+
+  // Construction inputs are captured when the store owner is acquired.
+  // Same-store callback identity changes intentionally keep that owner.
+  React.useLayoutEffect(() => {
+    const lease = acquireToolcraftSourceAssetOwner({
+      createCoordinator,
+      decorateCoordinator:
+        decorateToolcraftUnavailableResourceProofCoordinator,
+      onError: constructionOnError,
+      store,
+    });
+    setAcquisition({
+      lease,
+      store,
+    });
+    return lease.release;
+  }, [store]);
+
+  return activeLease
+    ? (
+      <ToolcraftSourceAssetProviderContent
+        binaryMediaHydrationJobs={binaryMediaHydrationJobs}
+        lease={activeLease}
+        store={store}
+      >
+        {children}
+      </ToolcraftSourceAssetProviderContent>
+    )
+    : <></>;
+}
+
+function ToolcraftSourceAssetProviderContent({
+  binaryMediaHydrationJobs,
+  children,
+  lease,
+  store,
+}: {
+  binaryMediaHydrationJobs: readonly ToolcraftBinaryMediaHydrationJob[];
+  children: React.ReactNode;
+  lease: ToolcraftSourceAssetOwnerLease;
+  store: ToolcraftExternalStore;
+}): React.JSX.Element {
+  const coordinator = lease.coordinator;
   const modelPresentation = useToolcraftModelPresentationMode();
   const customSourceTargets = React.useMemo(
     () => modelPresentation.mode === "custom"
@@ -333,8 +206,6 @@ export function ToolcraftSourceAssetProvider({
   );
 
   React.useEffect(() => {
-    const generation = ++owner.lifecycleGeneration;
-
     const hydrateModels = (): void => {
       const currentTargets = new Set<string>();
       for (const asset of store.getCommittedState().mediaAssets) {
@@ -346,22 +217,18 @@ export function ToolcraftSourceAssetProvider({
         ...hydratedModelTargetsRef.current,
         ...currentTargets,
       ])) {
-        owner.coordinator.clearPresentationFeedback(target);
+        coordinator.clearPresentationFeedback(target);
       }
       hydratedModelTargetsRef.current = currentTargets;
-      void owner.coordinator.hydrateModels().catch((error: unknown) => {
-        reportOwnerDisposeError(owner, error);
-      });
+      void coordinator.hydrateModels().catch(lease.reportError);
     };
     const unsubscribeHydration = store.subscribeSelector(
       selectModelHydrationFingerprint,
       hydrateModels,
     );
     const hydrateBinaryMedia = (): void => {
-      void owner.coordinator.hydrateBinaryMedia(binaryHydrationJobs).catch(
-        (error: unknown) => {
-          reportOwnerDisposeError(owner, error);
-        },
+      void coordinator.hydrateBinaryMedia(binaryHydrationJobs).catch(
+        lease.reportError,
       );
     };
     const unsubscribeBinaryHydration = store.subscribeSelector(
@@ -374,258 +241,32 @@ export function ToolcraftSourceAssetProvider({
     return () => {
       unsubscribeHydration();
       unsubscribeBinaryHydration();
-      queueMicrotask(() => {
-        if (
-          owner.lifecycleGeneration !== generation ||
-          sourceAssetOwners.get(store) !== owner
-        ) {
-          return;
-        }
-
-        sourceAssetOwners.delete(store);
-        try {
-          owner.presentationResources?.dispose();
-          void owner.coordinator.dispose().catch((error: unknown) => {
-            reportOwnerDisposeError(owner, error);
-          });
-        } catch (error) {
-          reportOwnerDisposeError(owner, error);
-        }
-      });
-    };
-  }, [binaryHydrationJobs, owner, store]);
-
-  React.useEffect(() => {
-    if (!toolcraftUnavailableResourceProofEnabled) return undefined;
-
-    const rootSelector = '[data-slot="toolcraft-runtime-app"]';
-    let pendingRequestId: string | null = null;
-
-    const publish = (
-      requestId: string,
-      observation: Readonly<Record<string, boolean | string>>,
-    ): void => {
-      const root = document.querySelector<HTMLElement>(rootSelector);
-      if (!root) return;
-      root.setAttribute(
-        TOOLCRAFT_UNAVAILABLE_RESOURCE_PROOF_ATTRIBUTE,
-        JSON.stringify({ requestId, ...observation }),
-      );
-    };
-
-    const handleRequest = (event: Event): void => {
-      const request = readUnavailableResourceProofRequest(event);
-      if (!request) return;
-
-      if (pendingRequestId) {
-        publish(request.requestId, {
-          message: `Unavailable-resource proof request "${pendingRequestId}" is still pending.`,
-          status: "error",
-        });
-        return;
-      }
-      pendingRequestId = request.requestId;
-
-      void (async () => {
-        if (request.action === "cleanup") {
-          const active = owner.activeUnavailableResourceProof;
-          if (
-            !active ||
-            active.requestId !== request.requestId
-          ) {
-            throw new Error(
-              "Unavailable-resource proof cleanup must match the active fixture request.",
-            );
-          }
-
-          owner.unavailableResourceProofRefs.delete(active.resourceRef);
-          const restoredBytes = await owner.coordinator.resolveResource?.(
-            active.resourceRef,
-            { signal: new AbortController().signal },
-          );
-          if (!restoredBytes?.byteLength) {
-            throw new Error(
-              "Unavailable-resource proof cleanup could not restore the real resolver.",
-            );
-          }
-          store.dispatch({
-            assetId: active.assetId,
-            expectedResourceRef: active.resourceRef,
-            lifecycle: "ready",
-            type: "media.setBinaryResourceState",
-          });
-          const restored = store
-            .getCommittedState()
-            .mediaAssets.find((asset) => asset.id === active.assetId);
-          if (
-            !restored ||
-            restored.assetKind !== "image" ||
-            restored.lifecycle !== "ready"
-          ) {
-            throw new Error(
-              "Unavailable-resource proof cleanup did not restore the typed resource state.",
-            );
-          }
-
-          owner.activeUnavailableResourceProof = null;
-          publish(request.requestId, {
-            assetId: active.assetId,
-            fileName: request.fileName,
-            lifecycle: "ready",
-            resolverAvailable: true,
-            status: "cleaned",
-          });
-          return;
-        }
-
-        if (owner.activeUnavailableResourceProof) {
-          throw new Error(
-            "Unavailable-resource proof supports exactly one active resource fixture.",
-          );
-        }
-        const candidates = store
-          .getCommittedState()
-          .mediaAssets.filter(
-            (
-              asset,
-            ): asset is ToolcraftImageAsset & { lifecycle: "ready" } =>
-              asset.assetKind === "image" &&
-              asset.lifecycle === "ready" &&
-              asset.fileName === request.fileName &&
-              (
-                request.sourceTarget === undefined ||
-                asset.sourceTarget === request.sourceTarget
-              ),
-          );
-        if (candidates.length !== 1) {
-          throw new Error(
-            `Unavailable-resource proof requires exactly one ready image named "${request.fileName}", received ${candidates.length}.`,
-          );
-        }
-
-        const asset = candidates[0]!;
-        const initialBytes = await owner.coordinator.resolveResource?.(
-          asset.resourceRef,
-          { signal: new AbortController().signal },
-        );
-        if (!initialBytes?.byteLength) {
-          throw new Error(
-            "Unavailable-resource proof requires a resource available through the real resolver before fault activation.",
-          );
-        }
-
-        owner.unavailableResourceProofRefs.add(asset.resourceRef);
-        try {
-          const faultedBytes = await owner.coordinator.resolveResource?.(
-            asset.resourceRef,
-            { signal: new AbortController().signal },
-          );
-          if (faultedBytes !== null) {
-            throw new Error(
-              "Unavailable-resource proof did not isolate the requested resolver resource.",
-            );
-          }
-          store.dispatch({
-            assetId: asset.id,
-            error: {
-              code: "browser-proof-resource-unavailable",
-              message:
-                "The resource is intentionally unavailable for protected browser proof.",
-            },
-            expectedResourceRef: asset.resourceRef,
-            lifecycle: "unavailable",
-            type: "media.setBinaryResourceState",
-          });
-          const unavailable = store
-            .getCommittedState()
-            .mediaAssets.find((candidate) => candidate.id === asset.id);
-          if (
-            !unavailable ||
-            unavailable.assetKind !== "image" ||
-            unavailable.lifecycle !== "unavailable"
-          ) {
-            throw new Error(
-              "Unavailable-resource proof did not reach the typed unavailable state.",
-            );
-          }
-
-          owner.activeUnavailableResourceProof = {
-            assetId: asset.id,
-            requestId: request.requestId,
-            resourceRef: asset.resourceRef,
-          };
-          publish(request.requestId, {
-            assetId: asset.id,
-            fileName: asset.fileName,
-            lifecycle: "unavailable",
-            resolverAvailable: false,
-            status: "active",
-          });
-        } catch (error) {
-          owner.unavailableResourceProofRefs.delete(asset.resourceRef);
-          throw error;
-        }
-      })()
-        .catch((error: unknown) => {
-          publish(request.requestId, {
-            message:
-              error instanceof Error
-                ? error.message
-                : "Unavailable-resource proof fixture failed.",
-            status: "error",
-          });
-        })
-        .finally(() => {
-          pendingRequestId = null;
-        });
-    };
-
-    document.addEventListener(
-      TOOLCRAFT_UNAVAILABLE_RESOURCE_PROOF_REQUEST,
-      handleRequest,
-    );
-
-    return () => {
-      document.removeEventListener(
-        TOOLCRAFT_UNAVAILABLE_RESOURCE_PROOF_REQUEST,
-        handleRequest,
-      );
-      const active = owner.activeUnavailableResourceProof;
-      if (!active) return;
-      owner.unavailableResourceProofRefs.delete(active.resourceRef);
-      store.dispatch({
-        assetId: active.assetId,
-        expectedResourceRef: active.resourceRef,
-        lifecycle: "ready",
-        type: "media.setBinaryResourceState",
-      });
-      owner.activeUnavailableResourceProof = null;
     };
-  }, [owner, store]);
+  }, [binaryHydrationJobs, coordinator, lease.reportError, store]);
 
   const context = (
     <ToolcraftMediaPresentationProvider
       bootstrapUrls={binaryBootstrapUrls}
-      resources={owner.presentationResources}
+      resources={lease.presentationResources}
     >
-      <ToolcraftSourceAssetCoordinatorContext.Provider value={owner.coordinator}>
+      <ToolcraftSourceAssetCoordinatorContext.Provider value={coordinator}>
         {children}
       </ToolcraftSourceAssetCoordinatorContext.Provider>
     </ToolcraftMediaPresentationProvider>
   );
 
-  return owner.coordinator.resolveResource ? (
+  return coordinator.resolveResource ? (
     <ToolcraftModelRenderProvider
       activeCustomTargets={activeCustomTargets}
-      clearPresentationFeedback={owner.coordinator.clearPresentationFeedback}
+      clearPresentationFeedback={coordinator.clearPresentationFeedback}
       customConsumers={
         modelPresentation.mode === "custom"
           ? modelPresentation.consumers
           : []
       }
-      reportPresentationFeedback={owner.coordinator.reportPresentationFeedback}
-      resolveResource={owner.coordinator.resolveResource}
-      retainResourceRef={owner.coordinator.retainResourceRef}
+      reportPresentationFeedback={coordinator.reportPresentationFeedback}
+      resolveResource={coordinator.resolveResource}
+      retainResourceRef={coordinator.retainResourceRef}
       visibleOrientationTarget={visibleOrientationTarget || undefined}
     >
       {context}