The exact media-type regex lived in object-url-lease.ts, browser-file-policy-registry.ts and the download validation; safeOpaqueValue (vault) and safeGeneratedToken (download) were the same regex; and five modules each defined their own positive-safe-integer check (isPositiveByteLimit included). file-policy.ts now exports one copy of each: EXACT_MEDIA_TYPE, isSafeGeneratedToken, isPositiveSafeInteger. ObjectUrlLeaseRegistry.create also loses an inner revoke branch that could never run (it required a non-empty string inside a "not a non-empty string" guard). cache-storage/public-cache-policy.ts keeps its private positiveSafeInteger: adapters may not import another adapter's module. Verified: a characterization test (unsafe reference -> UNAVAILABLE, 128-char token accepted, empty object URL -> no revoke, fractional/zero limits and a wildcard download media type rejected) passes on the code before and after. Lane gates pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
243 lines
7.4 KiB
TypeScript
243 lines
7.4 KiB
TypeScript
import type {
|
|
DownloadDeliveryPort,
|
|
FileContentPort,
|
|
FilePickerPort,
|
|
TransientPreviewPort,
|
|
} from "../../application/ports/browser-file-storage/file.ts";
|
|
import {
|
|
EnhancedFilePicker,
|
|
NativeInputFilePicker,
|
|
type NativeInputFilePickerOptions,
|
|
type SystemOpenPicker,
|
|
} from "./browser-file-picker.ts";
|
|
import {
|
|
BrowserFileVault,
|
|
DEFAULT_MAX_INSPECTION_BYTES,
|
|
type BrowserFileVaultOptions,
|
|
} from "./browser-file-vault.ts";
|
|
import {
|
|
BrowserFilePolicyRegistry,
|
|
type BrowserFilePolicyProfile,
|
|
} from "./browser-file-policy-registry.ts";
|
|
import {
|
|
createDownloadDeliveryAdapter,
|
|
type DownloadDeliveryAdapterOptions,
|
|
} from "./download-delivery-adapter.ts";
|
|
import type { BrowserFileObserver } from "./file-observer.ts";
|
|
import { isPositiveSafeInteger } from "./file-policy.ts";
|
|
import {
|
|
BrowserTransientPreview,
|
|
ObjectUrlLeaseRegistry,
|
|
type ObjectUrlApi,
|
|
} from "./object-url-lease.ts";
|
|
|
|
type UserActivationState = Readonly<{ isActive: boolean }>;
|
|
|
|
export type BrowserFileRuntimeOptions = Readonly<{
|
|
input: HTMLInputElement;
|
|
policies: readonly BrowserFilePolicyProfile[];
|
|
limits: Readonly<{
|
|
hardMaxPreviewBytes: number;
|
|
hardMaxObjectUrlBytes: number;
|
|
hardMaxTransferBytes: number;
|
|
hardMaxActiveFileReferences?: number;
|
|
hardMaxRetainedFileBytes?: number;
|
|
hardMaxActiveObjectUrls?: number;
|
|
hardMaxObjectUrlAggregateBytes?: number;
|
|
}>;
|
|
download: Omit<
|
|
DownloadDeliveryAdapterOptions,
|
|
| "objectUrls"
|
|
| "observer"
|
|
| "policies"
|
|
| "userActivation"
|
|
| "hardMaxObjectUrlBytes"
|
|
| "hardMaxTransferBytes"
|
|
>;
|
|
showOpenFilePicker?: SystemOpenPicker;
|
|
userActivation?: UserActivationState;
|
|
observer?: BrowserFileObserver;
|
|
objectUrlApi?: ObjectUrlApi;
|
|
vault?: Omit<BrowserFileVaultOptions, "observer" | "policies">;
|
|
nativePicker?: Pick<
|
|
NativeInputFilePickerOptions,
|
|
| "window"
|
|
| "scheduler"
|
|
| "focusFallbackGraceMs"
|
|
| "cancelFallbackDelayMs"
|
|
>;
|
|
hardForbiddenPreviewMediaTypes?: ReadonlySet<string>;
|
|
}>;
|
|
|
|
export type BrowserFileRuntime = Readonly<{
|
|
/**
|
|
* Canonical cross-browser control. Presentation decides which explicit
|
|
* user action invokes this baseline.
|
|
*/
|
|
baselinePicker: FilePickerPort;
|
|
/**
|
|
* Optional enhancement. It is never retried through baselinePicker in the
|
|
* same user activation.
|
|
*/
|
|
enhancedPicker: FilePickerPort | null;
|
|
content: FileContentPort;
|
|
previews: TransientPreviewPort;
|
|
downloads: DownloadDeliveryPort;
|
|
dispose(): void;
|
|
}>;
|
|
|
|
/**
|
|
* Optional feature factory. Nothing imports this from bootstrap, so browser
|
|
* file code remains outside the default bundle until a feature composes it.
|
|
*/
|
|
export function createBrowserFileRuntime(
|
|
options: BrowserFileRuntimeOptions,
|
|
): BrowserFileRuntime {
|
|
const limits = resolveRuntimeLimits(options.limits);
|
|
const policies = new BrowserFilePolicyRegistry({
|
|
profiles: options.policies,
|
|
hardLimits: {
|
|
maxInspectionBytes:
|
|
options.vault?.hardMaxInspectionBytes ??
|
|
DEFAULT_MAX_INSPECTION_BYTES,
|
|
maxRetainedFileBytes: limits.hardMaxRetainedFileBytes,
|
|
maxPreviewBytes: limits.hardMaxPreviewBytes,
|
|
maxObjectUrlBytes: limits.hardMaxObjectUrlBytes,
|
|
maxTransferBytes: limits.hardMaxTransferBytes,
|
|
},
|
|
});
|
|
const objectUrls = new ObjectUrlLeaseRegistry(
|
|
options.objectUrlApi,
|
|
{
|
|
hardMaxActiveLeases: limits.hardMaxActiveObjectUrls,
|
|
hardMaxSingleLeaseBytes: Math.max(
|
|
limits.hardMaxPreviewBytes,
|
|
limits.hardMaxObjectUrlBytes,
|
|
),
|
|
hardMaxAggregateLeaseBytes:
|
|
limits.hardMaxObjectUrlAggregateBytes,
|
|
},
|
|
);
|
|
const vault = new BrowserFileVault({
|
|
...options.vault,
|
|
policies,
|
|
hardMaxActiveReferences: limits.hardMaxActiveFileReferences,
|
|
hardMaxRetainedBytes: limits.hardMaxRetainedFileBytes,
|
|
observer: options.observer,
|
|
});
|
|
const commonPickerOptions = {
|
|
vault,
|
|
policies,
|
|
userActivation: options.userActivation,
|
|
observer: options.observer,
|
|
};
|
|
const baselinePicker = new NativeInputFilePicker({
|
|
...commonPickerOptions,
|
|
...options.nativePicker,
|
|
input: options.input,
|
|
systemOpenPickerSupported:
|
|
options.showOpenFilePicker !== undefined,
|
|
systemSavePickerSupported:
|
|
options.download.showSaveFilePicker !== undefined,
|
|
});
|
|
const enhancedPicker = options.showOpenFilePicker
|
|
? new EnhancedFilePicker({
|
|
...commonPickerOptions,
|
|
showOpenFilePicker: options.showOpenFilePicker,
|
|
systemSavePickerSupported:
|
|
options.download.showSaveFilePicker !== undefined,
|
|
})
|
|
: null;
|
|
const previews = new BrowserTransientPreview({
|
|
files: vault,
|
|
policies,
|
|
leases: objectUrls,
|
|
hardMaxPreviewBytes: limits.hardMaxPreviewBytes,
|
|
hardForbiddenMediaTypes:
|
|
options.hardForbiddenPreviewMediaTypes,
|
|
observer: options.observer,
|
|
});
|
|
const downloads = createDownloadDeliveryAdapter({
|
|
...options.download,
|
|
policies,
|
|
objectUrls,
|
|
hardMaxObjectUrlBytes: limits.hardMaxObjectUrlBytes,
|
|
hardMaxTransferBytes: limits.hardMaxTransferBytes,
|
|
observer: options.observer,
|
|
userActivation: options.userActivation,
|
|
});
|
|
let disposed = false;
|
|
|
|
return Object.freeze({
|
|
baselinePicker,
|
|
enhancedPicker,
|
|
content: vault,
|
|
previews,
|
|
downloads,
|
|
dispose(): void {
|
|
if (disposed) return;
|
|
disposed = true;
|
|
baselinePicker.dispose();
|
|
enhancedPicker?.dispose();
|
|
downloads.dispose();
|
|
previews.dispose();
|
|
vault.dispose();
|
|
},
|
|
});
|
|
}
|
|
|
|
type ResolvedRuntimeLimits = Readonly<{
|
|
hardMaxPreviewBytes: number;
|
|
hardMaxObjectUrlBytes: number;
|
|
hardMaxTransferBytes: number;
|
|
hardMaxActiveFileReferences: number;
|
|
hardMaxRetainedFileBytes: number;
|
|
hardMaxActiveObjectUrls: number;
|
|
hardMaxObjectUrlAggregateBytes: number;
|
|
}>;
|
|
|
|
function resolveRuntimeLimits(
|
|
limits: BrowserFileRuntimeOptions["limits"],
|
|
): ResolvedRuntimeLimits {
|
|
const hardMaxSingleObjectUrlBytes = Math.max(
|
|
limits.hardMaxPreviewBytes,
|
|
limits.hardMaxObjectUrlBytes,
|
|
);
|
|
const derivedAggregate = Math.min(
|
|
Number.MAX_SAFE_INTEGER,
|
|
hardMaxSingleObjectUrlBytes * 4,
|
|
);
|
|
const resolved = Object.freeze({
|
|
hardMaxPreviewBytes: limits.hardMaxPreviewBytes,
|
|
hardMaxObjectUrlBytes: limits.hardMaxObjectUrlBytes,
|
|
hardMaxTransferBytes: limits.hardMaxTransferBytes,
|
|
hardMaxActiveFileReferences:
|
|
limits.hardMaxActiveFileReferences ?? 32,
|
|
hardMaxRetainedFileBytes:
|
|
limits.hardMaxRetainedFileBytes ??
|
|
limits.hardMaxTransferBytes,
|
|
hardMaxActiveObjectUrls:
|
|
limits.hardMaxActiveObjectUrls ?? 16,
|
|
hardMaxObjectUrlAggregateBytes:
|
|
limits.hardMaxObjectUrlAggregateBytes ?? derivedAggregate,
|
|
});
|
|
if (
|
|
!isPositiveSafeInteger(resolved.hardMaxPreviewBytes) ||
|
|
!isPositiveSafeInteger(resolved.hardMaxObjectUrlBytes) ||
|
|
!isPositiveSafeInteger(resolved.hardMaxTransferBytes) ||
|
|
!isPositiveSafeInteger(resolved.hardMaxActiveFileReferences) ||
|
|
!isPositiveSafeInteger(resolved.hardMaxRetainedFileBytes) ||
|
|
!isPositiveSafeInteger(resolved.hardMaxActiveObjectUrls) ||
|
|
!isPositiveSafeInteger(resolved.hardMaxObjectUrlAggregateBytes) ||
|
|
resolved.hardMaxObjectUrlBytes >
|
|
resolved.hardMaxTransferBytes ||
|
|
resolved.hardMaxPreviewBytes >
|
|
resolved.hardMaxRetainedFileBytes ||
|
|
hardMaxSingleObjectUrlBytes >
|
|
resolved.hardMaxObjectUrlAggregateBytes
|
|
) {
|
|
throw new TypeError("Browser file runtime hard limits are invalid.");
|
|
}
|
|
return resolved;
|
|
}
|