@pascal-app/core 1.0.0-beta.5 → 1.0.0

package/dist/capture/schema.js

@@ -0,0 +1,348 @@
+import { z } from 'zod';
+const MetadataSchema = z.record(z.string(), z.unknown());
+export const CaptureSessionLocatorSchema = z.object({
+    sessionId: z.string().min(1),
+    manifestUrl: z.string().min(1).optional(),
+    schemaVersion: z.number().int().positive().optional(),
+    revisionId: z.string().min(1).optional(),
+});
+export const DeviceMotionSampleSchema = z.object({
+    segment: z.number().int().nonnegative(),
+    timestamp: z.number().nonnegative(),
+    transform: z.array(z.number()).length(16),
+});
+export const DeviceMotionTrajectorySchema = z.object({
+    coordinateSystem: z.string().min(1),
+    samples: z.array(DeviceMotionSampleSchema).min(2),
+});
+export const ArkitDeviceMotionTrajectorySchema = DeviceMotionTrajectorySchema.extend({
+    coordinateSystem: z.literal('arkit-world'),
+});
+export const PointCloudPayloadSchema = z
+    .object({
+    coordinateSystem: z.string().min(1),
+    positions: z.array(z.number().finite()).min(3),
+    colors: z.array(z.number().finite()).optional(),
+})
+    .superRefine((payload, context) => {
+    if (payload.positions.length % 3 !== 0) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Point-cloud positions must contain XYZ triples.',
+            path: ['positions'],
+        });
+    }
+    if (payload.colors && payload.colors.length !== payload.positions.length) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Point-cloud colors must match the positions array length.',
+            path: ['colors'],
+        });
+    }
+});
+export const ArkitPointCloudPayloadSchema = PointCloudPayloadSchema.safeExtend({
+    coordinateSystem: z.literal('arkit-world'),
+});
+const MAX_SURFACE_MESH_VERTICES = 65_535;
+const MAX_SURFACE_MESH_FACES = 20_000;
+export const SurfaceMeshPayloadSchema = z
+    .object({
+    version: z.literal(1),
+    coordinateSystem: z.string().min(1),
+    representation: z.literal('quantized-indexed-triangle-mesh'),
+    appearance: z.literal('camera-vertex-color'),
+    vertexCount: z.number().int().positive().max(MAX_SURFACE_MESH_VERTICES),
+    faceCount: z.number().int().positive().max(MAX_SURFACE_MESH_FACES),
+    boundsMin: z.array(z.number().finite()).length(3),
+    boundsMax: z.array(z.number().finite()).length(3),
+    positionEncoding: z.literal('uint16x3-base64-little-endian'),
+    colorEncoding: z.literal('uint8x3-base64-srgb'),
+    indexEncoding: z.literal('uint16x3-base64-little-endian'),
+    positions: z.string().min(1).max(524_280),
+    colors: z.string().min(1).max(262_140),
+    indices: z
+        .string()
+        .min(1)
+        .max(MAX_SURFACE_MESH_FACES * 8),
+})
+    .superRefine((payload, context) => {
+    if (payload.vertexCount > payload.faceCount * 3) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Surface meshes cannot contain more than three vertices per face.',
+            path: ['vertexCount'],
+        });
+    }
+    for (let axis = 0; axis < 3; axis += 1) {
+        if ((payload.boundsMax[axis] ?? 0) < (payload.boundsMin[axis] ?? 0)) {
+            context.addIssue({
+                code: 'custom',
+                message: 'Surface-mesh maximum bounds must not be below minimum bounds.',
+                path: ['boundsMax', axis],
+            });
+        }
+    }
+    const positionBytes = decodeBase64(payload.positions);
+    const colorBytes = decodeBase64(payload.colors);
+    const indexBytes = decodeBase64(payload.indices);
+    validateSurfaceMeshByteLength(positionBytes, payload.vertexCount * 3 * 2, 'positions', context);
+    validateSurfaceMeshByteLength(colorBytes, payload.vertexCount * 3, 'colors', context);
+    validateSurfaceMeshByteLength(indexBytes, payload.faceCount * 3 * 2, 'indices', context);
+    if (indexBytes?.byteLength === payload.faceCount * 3 * 2) {
+        const indices = new DataView(indexBytes.buffer, indexBytes.byteOffset, indexBytes.byteLength);
+        for (let offset = 0; offset < indexBytes.byteLength; offset += 2) {
+            if (indices.getUint16(offset, true) >= payload.vertexCount) {
+                context.addIssue({
+                    code: 'custom',
+                    message: 'Surface-mesh indices must reference an existing vertex.',
+                    path: ['indices'],
+                });
+                break;
+            }
+        }
+    }
+});
+export const ArkitSurfaceMeshPayloadSchema = SurfaceMeshPayloadSchema.safeExtend({
+    coordinateSystem: z.literal('arkit-world'),
+});
+export const CaptureTimeRangeSchema = z
+    .object({
+    start: z.number().nonnegative(),
+    end: z.number().nonnegative(),
+})
+    .refine((range) => range.end >= range.start, {
+    message: 'Capture time ranges must end at or after they start.',
+    path: ['end'],
+});
+export const CaptureArtifactReferenceSchema = z.object({
+    id: z.string().min(1),
+    uri: z.string().min(1).optional(),
+    mediaType: z.string().min(1),
+    byteLength: z.number().int().nonnegative().optional(),
+    sha256: z.string().min(1).optional(),
+    frameId: z.string().min(1).optional(),
+    timeRange: CaptureTimeRangeSchema.optional(),
+    metadata: MetadataSchema.optional(),
+});
+export const CaptureStreamDescriptorSchema = z.object({
+    id: z.string().min(1),
+    kind: z.string().min(1),
+    role: z.string().min(1).optional(),
+    availability: z.enum(['pending', 'live', 'ready', 'failed']).default('ready'),
+    frameId: z.string().min(1).optional(),
+    clockId: z.string().min(1).optional(),
+    artifact: CaptureArtifactReferenceSchema.optional(),
+    inline: z.unknown().optional(),
+    metadata: MetadataSchema.optional(),
+});
+export const CaptureClockSchema = z.object({
+    id: z.string().min(1),
+    timebase: z.enum(['seconds', 'milliseconds', 'microseconds', 'nanoseconds']),
+    epoch: z.string().min(1).optional(),
+});
+export const CaptureCoordinateFrameSchema = z.object({
+    id: z.string().min(1),
+    parentId: z.string().min(1).optional(),
+    convention: z.string().min(1),
+    transform: z.array(z.number()).length(16).optional(),
+});
+export const CaptureSessionManifestV1Schema = z.object({
+    schemaVersion: z.literal(1),
+    sessionId: z.string().min(1),
+    projectId: z.string().min(1),
+    streams: z.object({
+        roomModel: z
+            .object({
+            kind: z.literal('room-model'),
+            mediaType: z.literal('model/vnd.usdz+zip'),
+            url: z.string().min(1),
+        })
+            .optional(),
+        deviceMotion: z
+            .object({
+            kind: z.literal('device-motion'),
+            trajectory: ArkitDeviceMotionTrajectorySchema,
+        })
+            .optional(),
+        pointCloud: z
+            .object({
+            kind: z.literal('point-cloud'),
+            points: ArkitPointCloudPayloadSchema,
+        })
+            .optional(),
+        surfaceMesh: z
+            .object({
+            kind: z.literal('surface-mesh'),
+            mesh: ArkitSurfaceMeshPayloadSchema,
+        })
+            .optional(),
+    }),
+});
+export const CaptureSessionManifestV2Schema = z
+    .object({
+    schemaVersion: z.literal(2),
+    sessionId: z.string().min(1),
+    projectId: z.string().min(1).optional(),
+    revisionId: z.string().min(1).optional(),
+    state: z.enum(['live', 'finalizing', 'ready', 'failed']).default('ready'),
+    clocks: z.array(CaptureClockSchema).default([]),
+    coordinateFrames: z.array(CaptureCoordinateFrameSchema).default([]),
+    streams: z.array(CaptureStreamDescriptorSchema),
+    metadata: MetadataSchema.optional(),
+})
+    .superRefine(validateUniqueSessionIds);
+export const CaptureSessionManifestSchema = z.union([
+    CaptureSessionManifestV1Schema,
+    CaptureSessionManifestV2Schema,
+]);
+export const CaptureSessionDescriptorSchema = z
+    .object({
+    schemaVersion: z.number().int().positive(),
+    sessionId: z.string().min(1),
+    projectId: z.string().min(1).optional(),
+    revisionId: z.string().min(1).optional(),
+    state: z.enum(['live', 'finalizing', 'ready', 'failed']),
+    clocks: z.array(CaptureClockSchema),
+    coordinateFrames: z.array(CaptureCoordinateFrameSchema),
+    streams: z.array(CaptureStreamDescriptorSchema),
+    metadata: MetadataSchema.optional(),
+})
+    .superRefine(validateUniqueSessionIds);
+export function normalizeCaptureSessionManifest(value) {
+    const manifest = CaptureSessionManifestSchema.parse(value);
+    if (manifest.schemaVersion === 2)
+        return CaptureSessionDescriptorSchema.parse(manifest);
+    const streams = [];
+    if (manifest.streams.roomModel) {
+        streams.push({
+            id: 'room-model',
+            kind: manifest.streams.roomModel.kind,
+            role: 'model',
+            availability: 'ready',
+            artifact: {
+                id: `${manifest.sessionId}:room-model`,
+                mediaType: manifest.streams.roomModel.mediaType,
+                uri: manifest.streams.roomModel.url,
+            },
+        });
+    }
+    if (manifest.streams.deviceMotion) {
+        streams.push({
+            id: 'device-motion',
+            kind: manifest.streams.deviceMotion.kind,
+            role: 'deviceMotion',
+            availability: 'ready',
+            inline: manifest.streams.deviceMotion.trajectory,
+        });
+    }
+    if (manifest.streams.pointCloud) {
+        streams.push({
+            id: 'point-cloud',
+            kind: manifest.streams.pointCloud.kind,
+            role: 'pointCloud',
+            availability: 'ready',
+            inline: manifest.streams.pointCloud.points,
+        });
+    }
+    if (manifest.streams.surfaceMesh) {
+        streams.push({
+            id: 'surface-mesh',
+            kind: manifest.streams.surfaceMesh.kind,
+            role: 'surfaceMesh',
+            availability: 'ready',
+            inline: manifest.streams.surfaceMesh.mesh,
+        });
+    }
+    return CaptureSessionDescriptorSchema.parse({
+        schemaVersion: manifest.schemaVersion,
+        sessionId: manifest.sessionId,
+        projectId: manifest.projectId,
+        state: 'ready',
+        clocks: [],
+        coordinateFrames: [],
+        streams,
+    });
+}
+export function captureLayerKey(stream) {
+    if (stream.role)
+        return stream.role;
+    if (stream.kind === 'room-model')
+        return 'model';
+    if (stream.kind === 'device-motion')
+        return 'deviceMotion';
+    if (stream.kind === 'point-cloud')
+        return 'pointCloud';
+    if (stream.kind === 'surface-mesh')
+        return 'surfaceMesh';
+    if (stream.kind === 'gaussian-splat')
+        return 'splat';
+    return stream.kind;
+}
+export function captureStreamLabel(stream) {
+    const key = captureLayerKey(stream);
+    if (key === 'model')
+        return '3D model';
+    if (key === 'deviceMotion')
+        return 'Device motion';
+    if (key === 'pointCloud')
+        return 'Point cloud';
+    if (key === 'surfaceMesh')
+        return 'Surface mesh';
+    if (key === 'splat')
+        return 'Gaussian splat';
+    return key
+        .replace(/([a-z])([A-Z])/g, '$1 $2')
+        .replace(/[-_]+/g, ' ')
+        .replace(/^./, (value) => value.toUpperCase());
+}
+function validateSurfaceMeshByteLength(bytes, expectedLength, path, context) {
+    if (bytes?.byteLength === expectedLength)
+        return;
+    context.addIssue({
+        code: 'custom',
+        message: `Surface-mesh ${path} must contain exactly ${expectedLength} decoded bytes.`,
+        path: [path],
+    });
+}
+function decodeBase64(value) {
+    if (value.length % 4 !== 0 ||
+        !/^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{2}==|[A-Za-z\d+/]{3}=)?$/.test(value)) {
+        return null;
+    }
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const padding = value.endsWith('==') ? 2 : value.endsWith('=') ? 1 : 0;
+    const output = new Uint8Array((value.length / 4) * 3 - padding);
+    let outputIndex = 0;
+    for (let index = 0; index < value.length; index += 4) {
+        const a = alphabet.indexOf(value[index] ?? '');
+        const b = alphabet.indexOf(value[index + 1] ?? '');
+        const c = value[index + 2] === '=' ? 0 : alphabet.indexOf(value[index + 2] ?? '');
+        const d = value[index + 3] === '=' ? 0 : alphabet.indexOf(value[index + 3] ?? '');
+        const bits = a * 262_144 + b * 4096 + c * 64 + d;
+        if (outputIndex < output.length)
+            output[outputIndex++] = Math.floor(bits / 65_536) % 256;
+        if (outputIndex < output.length)
+            output[outputIndex++] = Math.floor(bits / 256) % 256;
+        if (outputIndex < output.length)
+            output[outputIndex++] = bits % 256;
+    }
+    return output;
+}
+function validateUniqueSessionIds(value, context) {
+    validateUniqueIds(value.streams, 'streams', context);
+    validateUniqueIds(value.clocks, 'clocks', context);
+    validateUniqueIds(value.coordinateFrames, 'coordinateFrames', context);
+}
+function validateUniqueIds(values, path, context) {
+    const seen = new Set();
+    values.forEach((value, index) => {
+        if (seen.has(value.id)) {
+            context.addIssue({
+                code: 'custom',
+                message: `Duplicate capture ${path} id: ${value.id}`,
+                path: [path, index, 'id'],
+            });
+        }
+        seen.add(value.id);
+    });
+}

package/dist/capture/source.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { type CaptureArtifactReference, type CaptureSessionDescriptor, type CaptureSessionLocator } from './schema';
+export declare const CaptureStreamPacketSchema: z.ZodObject<{
+    protocolVersion: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    streamId: z.ZodString;
+    generation: z.ZodNumber;
+    sequence: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    frameId: z.ZodOptional<z.ZodString>;
+    keyframe: z.ZodOptional<z.ZodBoolean>;
+    bounds: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    payload: z.ZodUnknown;
+}, z.core.$strip>;
+export type CaptureStreamPacket = z.infer<typeof CaptureStreamPacketSchema>;
+export type CaptureSourceEvent = {
+    type: 'descriptor';
+    descriptor: CaptureSessionDescriptor;
+} | {
+    type: 'packet';
+    packet: CaptureStreamPacket;
+} | {
+    type: 'closed';
+};
+export type CaptureArtifactResolution = {
+    url: string;
+    dispose?: () => void;
+};
+export type CaptureSubscriptionOptions = {
+    signal?: AbortSignal;
+    streamIds?: readonly string[];
+};
+export interface CaptureSource {
+    describe(signal?: AbortSignal): Promise<CaptureSessionDescriptor>;
+    resolveArtifact?(artifact: CaptureArtifactReference, signal?: AbortSignal): Promise<CaptureArtifactResolution>;
+    subscribe?(options?: CaptureSubscriptionOptions): AsyncIterable<CaptureSourceEvent>;
+}
+export type CaptureSourceResolver = (locator: CaptureSessionLocator) => CaptureSource | Promise<CaptureSource>;
+export type HttpCaptureSourceOptions = {
+    credentials?: RequestCredentials;
+    fetch?: typeof globalThis.fetch;
+    headers?: HeadersInit;
+    manifestUrl?: (locator: CaptureSessionLocator) => string;
+    resolveArtifact?: (artifact: CaptureArtifactReference, signal?: AbortSignal) => Promise<CaptureArtifactResolution>;
+};
+export type PushCaptureSourceOptions = {
+    maxQueuedEventsPerSubscriber?: number;
+};
+export declare function createHttpCaptureSource(locatorInput: CaptureSessionLocator, options?: HttpCaptureSourceOptions): CaptureSource;
+export declare class PushCaptureSource implements CaptureSource {
+    #private;
+    constructor(descriptor: CaptureSessionDescriptor, options?: PushCaptureSourceOptions);
+    describe(): Promise<CaptureSessionDescriptor>;
+    resolveArtifact(artifact: CaptureArtifactReference): Promise<CaptureArtifactResolution>;
+    subscribe(options?: CaptureSubscriptionOptions): AsyncIterable<CaptureSourceEvent>;
+    updateDescriptor(descriptor: CaptureSessionDescriptor): void;
+    publishPacket(packetInput: CaptureStreamPacket): void;
+    close(): void;
+}
+//# sourceMappingURL=source.d.ts.map

package/dist/capture/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/capture/source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,wBAAwB,EAE7B,KAAK,qBAAqB,EAG3B,MAAM,UAAU,CAAA;AAEjB,eAAO,MAAM,yBAAyB;;;;;;;;;;;iBAapC,CAAA;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,wBAAwB,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEtB,MAAM,MAAM,yBAAyB,GAAG;IACtC,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAA;IACjE,eAAe,CAAC,CACd,QAAQ,EAAE,wBAAwB,EAClC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,yBAAyB,CAAC,CAAA;IACrC,SAAS,CAAC,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,aAAa,CAAC,kBAAkB,CAAC,CAAA;CACpF;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,OAAO,EAAE,qBAAqB,KAC3B,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC,CAAA;AAE3C,MAAM,MAAM,wBAAwB,GAAG;IACrC,WAAW,CAAC,EAAE,kBAAkB,CAAA;IAChC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAA;IAC/B,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,qBAAqB,KAAK,MAAM,CAAA;IACxD,eAAe,CAAC,EAAE,CAChB,QAAQ,EAAE,wBAAwB,EAClC,MAAM,CAAC,EAAE,WAAW,KACjB,OAAO,CAAC,yBAAyB,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,4BAA4B,CAAC,EAAE,MAAM,CAAA;CACtC,CAAA;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,qBAAqB,EACnC,OAAO,GAAE,wBAA6B,GACrC,aAAa,CAwCf;AAmCD,qBAAa,iBAAkB,YAAW,aAAa;;gBAMzC,UAAU,EAAE,wBAAwB,EAAE,OAAO,GAAE,wBAA6B;IAKlF,QAAQ,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAI7C,eAAe,CAAC,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAK7F,SAAS,CAAC,OAAO,GAAE,0BAA+B,GAAG,aAAa,CAAC,kBAAkB,CAAC;IAyBtF,gBAAgB,CAAC,UAAU,EAAE,wBAAwB,GAAG,IAAI;IAU5D,aAAa,CAAC,WAAW,EAAE,mBAAmB,GAAG,IAAI;IAYrD,KAAK,IAAI,IAAI;CAqBd"}

package/dist/capture/source.js

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+import { CaptureSessionDescriptorSchema, CaptureSessionLocatorSchema, normalizeCaptureSessionManifest, } from './schema';
+export const CaptureStreamPacketSchema = z.object({
+    protocolVersion: z.literal(1),
+    sessionId: z.string().min(1),
+    streamId: z.string().min(1),
+    generation: z.number().int().nonnegative(),
+    sequence: z.number().int().nonnegative(),
+    timestamp: z.number().nonnegative(),
+    frameId: z.string().min(1).optional(),
+    keyframe: z.boolean().optional(),
+    bounds: z
+        .tuple([z.number(), z.number(), z.number(), z.number(), z.number(), z.number()])
+        .optional(),
+    payload: z.unknown(),
+});
+export function createHttpCaptureSource(locatorInput, options = {}) {
+    const locator = CaptureSessionLocatorSchema.parse(locatorInput);
+    const manifestUrl = locator.manifestUrl ?? options.manifestUrl?.(locator);
+    if (!manifestUrl)
+        throw new Error(`Capture session ${locator.sessionId} has no manifest URL.`);
+    let descriptorPromise = null;
+    const loadDescriptor = async () => {
+        const fetcher = options.fetch ?? globalThis.fetch;
+        const response = await fetcher(manifestUrl, {
+            credentials: options.credentials,
+            headers: options.headers,
+        });
+        if (!response.ok)
+            throw new Error(`Capture session ${locator.sessionId} is unavailable.`);
+        const descriptor = normalizeCaptureSessionManifest(await response.json());
+        if (descriptor.sessionId !== locator.sessionId) {
+            throw new Error(`Capture manifest session does not match ${locator.sessionId}.`);
+        }
+        if (locator.schemaVersion && descriptor.schemaVersion !== locator.schemaVersion) {
+            throw new Error(`Capture manifest schema does not match version ${locator.schemaVersion}.`);
+        }
+        if (locator.revisionId && descriptor.revisionId !== locator.revisionId) {
+            throw new Error(`Capture manifest revision does not match ${locator.revisionId}.`);
+        }
+        return descriptor;
+    };
+    return {
+        describe(signal) {
+            descriptorPromise ??= loadDescriptor().catch((cause) => {
+                descriptorPromise = null;
+                throw cause;
+            });
+            return waitForPromise(descriptorPromise, signal).then(cloneCaptureDescriptor);
+        },
+        async resolveArtifact(artifact, signal) {
+            if (options.resolveArtifact)
+                return options.resolveArtifact(artifact, signal);
+            if (!artifact.uri)
+                throw new Error(`Capture artifact ${artifact.id} has no URI.`);
+            return { url: resolveArtifactUri(artifact.uri, manifestUrl) };
+        },
+    };
+}
+function waitForPromise(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError());
+        signal.addEventListener('abort', onAbort, { once: true });
+        void promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+function abortError() {
+    const error = new Error('The capture request was aborted.');
+    error.name = 'AbortError';
+    return error;
+}
+function resolveArtifactUri(uri, manifestUrl) {
+    try {
+        const base = typeof globalThis.location === 'undefined'
+            ? new URL(manifestUrl)
+            : new URL(manifestUrl, globalThis.location.href);
+        return new URL(uri, base).toString();
+    }
+    catch {
+        return uri;
+    }
+}
+export class PushCaptureSource {
+    #closed = false;
+    #descriptor;
+    #maxQueuedEventsPerSubscriber;
+    #subscribers = new Set();
+    constructor(descriptor, options = {}) {
+        this.#descriptor = cloneCaptureDescriptor(descriptor);
+        this.#maxQueuedEventsPerSubscriber = Math.max(1, options.maxQueuedEventsPerSubscriber ?? 32);
+    }
+    async describe() {
+        return cloneCaptureDescriptor(this.#descriptor);
+    }
+    async resolveArtifact(artifact) {
+        if (!artifact.uri)
+            throw new Error(`Capture artifact ${artifact.id} has no URI.`);
+        return { url: artifact.uri };
+    }
+    subscribe(options = {}) {
+        let cleanupAbort = () => { };
+        let subscriber;
+        const iterator = new EventIterator(() => {
+            cleanupAbort();
+            this.#subscribers.delete(subscriber);
+        }, this.#maxQueuedEventsPerSubscriber);
+        subscriber = {
+            iterator,
+            streamIds: options.streamIds ? new Set(options.streamIds) : null,
+        };
+        this.#subscribers.add(subscriber);
+        if (this.#closed) {
+            iterator.close({ type: 'closed' });
+        }
+        else if (options.signal) {
+            if (options.signal.aborted)
+                iterator.finish();
+            else {
+                const onAbort = () => iterator.finish();
+                options.signal.addEventListener('abort', onAbort, { once: true });
+                cleanupAbort = () => options.signal?.removeEventListener('abort', onAbort);
+            }
+        }
+        return iterator;
+    }
+    updateDescriptor(descriptor) {
+        if (this.#closed)
+            return;
+        const nextDescriptor = cloneCaptureDescriptor(descriptor);
+        if (nextDescriptor.sessionId !== this.#descriptor.sessionId) {
+            throw new Error('A capture source cannot change session identity.');
+        }
+        this.#descriptor = nextDescriptor;
+        this.#publish({ type: 'descriptor', descriptor: cloneCaptureDescriptor(nextDescriptor) });
+    }
+    publishPacket(packetInput) {
+        if (this.#closed)
+            return;
+        const packet = CaptureStreamPacketSchema.parse(packetInput);
+        if (packet.sessionId !== this.#descriptor.sessionId) {
+            throw new Error(`Capture packet does not belong to ${this.#descriptor.sessionId}.`);
+        }
+        if (!this.#descriptor.streams.some((stream) => stream.id === packet.streamId)) {
+            throw new Error(`Capture packet references unknown stream ${packet.streamId}.`);
+        }
+        this.#publish({ type: 'packet', packet });
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const subscriber of this.#subscribers) {
+            subscriber.iterator.close({ type: 'closed' });
+        }
+        this.#subscribers.clear();
+    }
+    #publish(event) {
+        for (const subscriber of this.#subscribers) {
+            if (event.type === 'packet' &&
+                subscriber.streamIds &&
+                !subscriber.streamIds.has(event.packet.streamId)) {
+                continue;
+            }
+            subscriber.iterator.push(cloneCaptureSourceEvent(event));
+        }
+    }
+}
+class EventIterator {
+    #done = false;
+    #maxQueuedEvents;
+    #onFinish;
+    #queue = [];
+    #waiters = [];
+    constructor(onFinish, maxQueuedEvents) {
+        this.#onFinish = onFinish;
+        this.#maxQueuedEvents = maxQueuedEvents;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    next() {
+        const event = this.#queue.shift();
+        if (event)
+            return Promise.resolve({ done: false, value: event });
+        if (this.#done)
+            return Promise.resolve({ done: true, value: undefined });
+        return new Promise((resolve) => this.#waiters.push(resolve));
+    }
+    return() {
+        this.finish();
+        return Promise.resolve({ done: true, value: undefined });
+    }
+    push(event) {
+        if (this.#done)
+            return;
+        const waiter = this.#waiters.shift();
+        if (waiter)
+            waiter({ done: false, value: event });
+        else {
+            this.#queue.push(event);
+            this.#trimQueue();
+        }
+    }
+    close(event) {
+        if (this.#done)
+            return;
+        this.#done = true;
+        this.#queue = [];
+        const waiter = this.#waiters.shift();
+        if (waiter)
+            waiter({ done: false, value: event });
+        else
+            this.#queue.push(event);
+        for (const pending of this.#waiters.splice(0))
+            pending({ done: true, value: undefined });
+        this.#onFinish();
+    }
+    finish() {
+        if (this.#done) {
+            this.#queue = [];
+            return;
+        }
+        this.#done = true;
+        this.#queue = [];
+        this.#onFinish();
+        for (const waiter of this.#waiters.splice(0))
+            waiter({ done: true, value: undefined });
+    }
+    #trimQueue() {
+        while (this.#queue.length > this.#maxQueuedEvents) {
+            const packetIndex = this.#queue.findIndex((event) => event.type === 'packet');
+            this.#queue.splice(packetIndex >= 0 ? packetIndex : 0, 1);
+        }
+    }
+}
+function cloneCaptureDescriptor(descriptor) {
+    return CaptureSessionDescriptorSchema.parse(structuredClone(descriptor));
+}
+function cloneCaptureSourceEvent(event) {
+    if (event.type === 'descriptor') {
+        return { type: 'descriptor', descriptor: cloneCaptureDescriptor(event.descriptor) };
+    }
+    if (event.type === 'packet') {
+        return {
+            type: 'packet',
+            packet: CaptureStreamPacketSchema.parse(structuredClone(event.packet)),
+        };
+    }
+    return { type: 'closed' };
+}