@tongue-core/project 0.1.0-rc.8 → 0.1.0-rc.9

package/README.md

@@ -24,6 +24,7 @@ The SDK is that host on a machine with files and processes.
 | `@tongue-core/project/build` | the project's shape (`roleOf`), the compiler (`compileModule`), bundles, `compileProject` → `loadProject` → `extractFilm` → `writeBuild`, or `buildProject` for all four | whatever builds projects (the SDK, a backend) |
 | `@tongue-core/project/load` | `ModuleHost`, linking bundles, `openBuild` (build.json, film.json and every bundle, hashes checked), `filmFromModules` (bundles a bundler already imported) | renderers, players, Workers |
 | `@tongue-core/project/template` | the template format (`template.json`), `TemplateSource`, `projectFromTemplate` | `tongue init`, apps with template catalogs |
+| `@tongue-core/project/media` | media identities, prepared-media schema, shared HTTP transport and typed failures | SDK acquisition, browser playback, host storage adapters |
 
 `@tongue-core/project` exports all of it.
 

package/dist/build/extract.d.ts

@@ -42,21 +42,29 @@ export declare const extractFilm: (project: LoadedProject, options?: ExtractOpti
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;

package/dist/build/write.d.ts

@@ -5,6 +5,7 @@ import type { ModuleHost } from "../load/host.js";
 import { type CompiledProject } from "./compile-project.js";
 import { type ExtractOptions } from "./extract.js";
 import type { ProjectFiles } from "./layout.js";
+import type { MediaOriginal } from "../media/media.js";
 export declare const BUILD_FILE = "build.json";
 export declare const FILM_DOC_FILE = "film.json";
 /** Where a build keeps its imported assets. */
@@ -26,6 +27,7 @@ export interface WriteOptions {
     readonly tongue: string;
     /** The imported asset files the film loads, as the host found them. */
     readonly assets: ReadonlyArray<AssetFile>;
+    readonly originals?: ReadonlyArray<MediaOriginal>;
 }
 /** The files of a build of `compiled`, whose timeline is `doc`. */
 export declare function writeBuild(compiled: CompiledProject, doc: FilmDoc, options: WriteOptions): Build;

package/dist/build/write.js

@@ -18,6 +18,7 @@ export function writeBuild(compiled, doc, options) {
     const manifest = {
         format: BUILD_FORMAT, version: BUILD_VERSION, tongue: options.tongue, project: compiled.manifest.name, source: compiled.source,
         film: FILM_DOC_FILE, assets: { dir: ASSETS_DIR, files },
+        ...(options.originals && options.originals.length > 0 ? { originals: options.originals } : {}),
     };
     return {
         manifest,

package/dist/doc/assemble.d.ts

@@ -40,21 +40,29 @@ export declare const assembleFilm: (doc: {
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;
@@ -262,21 +270,29 @@ export declare const sceneFilmDoc: (doc: {
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;
@@ -481,21 +497,29 @@ export declare const sceneFilmDoc: (doc: {
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;

package/dist/doc/assemble.js

@@ -1,21 +1,22 @@
-import { audio, Clip, Film, font, fromJson, image, narration, SchemaError, Track, Transition, video, } from "@tongue-core/film";
+import { audio, Clip, collectAssetsSync, Film, font, fromJson, image, narration, SchemaError, Track, Transition, video, } from "@tongue-core/film";
 import { setOrigin } from "@tongue-core/film/model";
 import { Effect } from "effect";
 import { DocError } from "../errors.js";
 import { docError } from "./issues.js";
 /** The film's assets, made from the document: each once per kind and name, in its order. */
 export function assetsOf(doc) {
-    return doc.assets.map((a) => {
+    return collectAssetsSync(() => doc.assets.map((a) => {
+        const identity = { ...(a.sha256 === undefined ? {} : { sha256: a.sha256 }), ...(a.prepared === undefined ? {} : { prepared: a.prepared }) };
         switch (a.kind) {
             case "font": {
                 const italic = a.italic === undefined ? undefined : doc.assets.find((other) => other.kind === "font" && other.name === a.italic);
-                return font(a.source, italic ? { name: a.name, italic: italic.source } : { name: a.name });
+                return font(a.source, { name: a.name, ...identity, ...(italic ? { italic: italic.source } : {}) });
             }
-            case "image": return image(a.source, { name: a.name, maxSize: a.maxSize });
-            case "video": return video(a.source, { name: a.name, maxSize: a.maxSize });
-            case "audio": return audio(a.source, { name: a.name });
+            case "image": return image(a.source, { name: a.name, maxSize: a.maxSize, ...identity });
+            case "video": return video(a.source, { name: a.name, maxSize: a.maxSize, ...identity });
+            case "audio": return audio(a.source, { name: a.name, ...identity });
         }
-    });
+    })).value;
 }
 /** Finds the document's assets by kind and name. */
 export function assetLookup(assets) {

package/dist/doc/build-doc.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Schema } from "effect";
 export declare const BUILD_FORMAT = "tongue.build";
-export declare const BUILD_VERSION = 1;
+export declare const BUILD_VERSION = 2;
 /** One imported asset file: fonts/inter.ttf, images/dusk.qoi, video/aurora/info.json… */
 export declare const AssetFile: Schema.Struct<{
     /** Relative to the build's assets folder. */
@@ -8,11 +8,13 @@ export declare const AssetFile: Schema.Struct<{
     readonly bytes: Schema.Int;
     /** SHA-256 of the file, hex. */
     readonly hash: Schema.String;
+    /** Absent for a file packaged in the build. */
+    readonly url: Schema.optionalKey<Schema.String>;
 }>;
 export type AssetFile = typeof AssetFile.Type;
 export declare const BuildDoc: Schema.Struct<{
     readonly format: Schema.Literal<"tongue.build">;
-    readonly version: Schema.Literal<1>;
+    readonly version: Schema.Literals<readonly [1, 2]>;
     /** The Tongue version that built it. */
     readonly tongue: Schema.String;
     /** The project's name, from tongue.json. */
@@ -30,25 +32,43 @@ export declare const BuildDoc: Schema.Struct<{
             readonly bytes: Schema.Int;
             /** SHA-256 of the file, hex. */
             readonly hash: Schema.String;
+            /** Absent for a file packaged in the build. */
+            readonly url: Schema.optionalKey<Schema.String>;
         }>>;
     }>;
+    /** Pinned remote originals: enough to render a build on another machine. */
+    readonly originals: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["font", "image", "audio", "video"]>;
+        readonly name: Schema.String;
+        readonly source: Schema.String;
+        readonly hash: Schema.String;
+        readonly bytes: Schema.Int;
+    }>>>;
 }>;
 export type BuildDoc = typeof BuildDoc.Type;
 export declare const formatBuildDoc: (doc: BuildDoc) => string;
 /** build.json's text as a checked document. */
 export declare const parseBuildDoc: (text: string) => Effect.Effect<{
-    readonly format: "tongue.build";
-    readonly version: 1;
-    readonly tongue: string;
-    readonly project: string;
-    readonly source: string;
-    readonly film: string;
     readonly assets: {
         readonly dir: string;
         readonly files: readonly {
             readonly path: string;
-            readonly bytes: number;
             readonly hash: string;
+            readonly bytes: number;
+            readonly url?: string | undefined;
         }[];
     };
+    readonly source: string;
+    readonly format: "tongue.build";
+    readonly version: 2 | 1;
+    readonly film: string;
+    readonly tongue: string;
+    readonly project: string;
+    readonly originals?: readonly {
+        readonly kind: "font" | "image" | "video" | "audio";
+        readonly name: string;
+        readonly source: string;
+        readonly hash: string;
+        readonly bytes: number;
+    }[] | undefined;
 }, import("../errors.js").DocError, never>;

package/dist/doc/build-doc.js

@@ -1,22 +1,25 @@
 import { Effect, Schema } from "effect";
 import { docError, schemaProblems } from "./issues.js";
+import { MediaOriginal, MediaPath, MediaUrl } from "../media/media.js";
 // build.json: the entry point of a build. What made it, from which sources, where its film.json is
 // (the scene bundles are listed in film.json), and the imported asset files it needs, with their
 // sizes and hashes: what a player loads, shows progress for, and caches by.
 export const BUILD_FORMAT = "tongue.build";
-export const BUILD_VERSION = 1;
+export const BUILD_VERSION = 2;
 const HASH = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/, { message: "a SHA-256 hash (64 hex digits)" }));
 /** One imported asset file: fonts/inter.ttf, images/dusk.qoi, video/aurora/info.json… */
 export const AssetFile = Schema.Struct({
     /** Relative to the build's assets folder. */
-    path: Schema.String,
+    path: MediaPath,
     bytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
     /** SHA-256 of the file, hex. */
     hash: HASH,
+    /** Absent for a file packaged in the build. */
+    url: Schema.optionalKey(MediaUrl),
 });
 export const BuildDoc = Schema.Struct({
     format: Schema.Literal(BUILD_FORMAT),
-    version: Schema.Literal(BUILD_VERSION),
+    version: Schema.Literals([1, BUILD_VERSION]),
     /** The Tongue version that built it. */
     tongue: Schema.String,
     /** The project's name, from tongue.json. */
@@ -27,11 +30,29 @@ export const BuildDoc = Schema.Struct({
     film: Schema.String,
     /** The imported asset files the film loads: where they are (relative to the build), and each one. */
     assets: Schema.Struct({ dir: Schema.String, files: Schema.Array(AssetFile) }),
+    /** Pinned remote originals: enough to render a build on another machine. */
+    originals: Schema.optionalKey(Schema.Array(MediaOriginal)),
 });
 export const formatBuildDoc = (doc) => `${JSON.stringify(doc, null, 2)}\n`;
 const decode = Schema.decodeUnknownEffect(BuildDoc);
 /** build.json's text as a checked document. */
 export const parseBuildDoc = Effect.fn("parseBuildDoc")(function* (text) {
     const json = yield* Effect.try({ try: () => JSON.parse(text), catch: (e) => docError("build.json isn't JSON", [{ path: "", message: e instanceof Error ? e.message : String(e) }]) });
-    return yield* decode(json, { errors: "all" }).pipe(Effect.mapError((e) => docError("build.json isn't a version 1 build", schemaProblems(e))));
+    const doc = yield* decode(json, { errors: "all" }).pipe(Effect.mapError((e) => docError("build.json isn't a supported build", schemaProblems(e))));
+    if (doc.version === 1 && (doc.originals !== undefined || doc.assets.files.some((file) => file.url !== undefined)))
+        return yield* docError("Remote assets require build format version 2", []);
+    const paths = new Set();
+    for (const file of doc.assets.files) {
+        if (paths.has(file.path))
+            return yield* docError("build.json has duplicate asset paths", [{ path: file.path, message: "duplicate asset file" }]);
+        paths.add(file.path);
+    }
+    const originals = new Set();
+    for (const original of doc.originals ?? []) {
+        const key = `${original.kind}:${original.name}`;
+        if (originals.has(key))
+            return yield* docError("build.json has duplicate original identities", [{ path: "originals", message: key }]);
+        originals.add(key);
+    }
+    return doc;
 });

package/dist/doc/check.d.ts

@@ -34,21 +34,29 @@ export declare const decodeFilmDoc: (json: unknown) => Effect.Effect<{
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;
@@ -255,21 +263,29 @@ export declare const parseFilmDoc: (text: string) => Effect.Effect<{
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;

package/dist/doc/film-doc.d.ts

@@ -49,19 +49,27 @@ export declare const AssetDoc: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"font">;
     readonly name: Schema.String;
     readonly source: Schema.String;
+    readonly sha256: Schema.optionalKey<Schema.String>;
+    readonly prepared: Schema.optionalKey<Schema.String>;
     /** The name of the font asset `fontStyle: "italic"` uses. */
     readonly italic: Schema.optionalKey<Schema.String>;
 }>, Schema.Struct<{
+    readonly sha256: Schema.optionalKey<Schema.String>;
+    readonly prepared: Schema.optionalKey<Schema.String>;
     readonly kind: Schema.Literal<"image">;
     readonly name: Schema.String;
     readonly source: Schema.String;
     readonly maxSize: Schema.Int;
 }>, Schema.Struct<{
+    readonly sha256: Schema.optionalKey<Schema.String>;
+    readonly prepared: Schema.optionalKey<Schema.String>;
     readonly kind: Schema.Literal<"video">;
     readonly name: Schema.String;
     readonly source: Schema.String;
     readonly maxSize: Schema.Int;
 }>, Schema.Struct<{
+    readonly sha256: Schema.optionalKey<Schema.String>;
+    readonly prepared: Schema.optionalKey<Schema.String>;
     readonly kind: Schema.Literal<"audio">;
     readonly name: Schema.String;
     readonly source: Schema.String;
@@ -674,19 +682,27 @@ export declare const FilmDoc: Schema.Struct<{
         readonly kind: Schema.Literal<"font">;
         readonly name: Schema.String;
         readonly source: Schema.String;
+        readonly sha256: Schema.optionalKey<Schema.String>;
+        readonly prepared: Schema.optionalKey<Schema.String>;
         /** The name of the font asset `fontStyle: "italic"` uses. */
         readonly italic: Schema.optionalKey<Schema.String>;
     }>, Schema.Struct<{
+        readonly sha256: Schema.optionalKey<Schema.String>;
+        readonly prepared: Schema.optionalKey<Schema.String>;
         readonly kind: Schema.Literal<"image">;
         readonly name: Schema.String;
         readonly source: Schema.String;
         readonly maxSize: Schema.Int;
     }>, Schema.Struct<{
+        readonly sha256: Schema.optionalKey<Schema.String>;
+        readonly prepared: Schema.optionalKey<Schema.String>;
         readonly kind: Schema.Literal<"video">;
         readonly name: Schema.String;
         readonly source: Schema.String;
         readonly maxSize: Schema.Int;
     }>, Schema.Struct<{
+        readonly sha256: Schema.optionalKey<Schema.String>;
+        readonly prepared: Schema.optionalKey<Schema.String>;
         readonly kind: Schema.Literal<"audio">;
         readonly name: Schema.String;
         readonly source: Schema.String;

package/dist/doc/film-doc.js

@@ -56,12 +56,15 @@ const FontDoc = Schema.Struct({
     kind: Schema.Literal("font"),
     name: Name,
     source: Schema.String,
+    sha256: Schema.optionalKey(Schema.String),
+    prepared: Schema.optionalKey(Schema.String),
     /** The name of the font asset `fontStyle: "italic"` uses. */
     italic: Schema.optionalKey(Name),
 });
-const ImageDoc = Schema.Struct({ kind: Schema.Literal("image"), name: Name, source: Schema.String, maxSize: Pixels });
-const VideoDoc = Schema.Struct({ kind: Schema.Literal("video"), name: Name, source: Schema.String, maxSize: Pixels });
-const AudioDoc = Schema.Struct({ kind: Schema.Literal("audio"), name: Name, source: Schema.String });
+const SourceOptions = { sha256: Schema.optionalKey(Schema.String), prepared: Schema.optionalKey(Schema.String) };
+const ImageDoc = Schema.Struct({ kind: Schema.Literal("image"), name: Name, source: Schema.String, maxSize: Pixels, ...SourceOptions });
+const VideoDoc = Schema.Struct({ kind: Schema.Literal("video"), name: Name, source: Schema.String, maxSize: Pixels, ...SourceOptions });
+const AudioDoc = Schema.Struct({ kind: Schema.Literal("audio"), name: Name, source: Schema.String, ...SourceOptions });
 /** A file the film loads; `source` is relative to the project. Names are unique per kind. */
 export const AssetDoc = Schema.Union([FontDoc, ImageDoc, VideoDoc, AudioDoc]);
 // ---------------------------------------------------------------- clips

package/dist/doc/from-plan.d.ts

@@ -39,21 +39,29 @@ export declare const filmDocOf: (plan: FilmPlan, background: string, scenes: rea
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;

package/dist/doc/from-plan.js

@@ -88,11 +88,12 @@ function kitDoc(kit, scenes) {
     return { kit: jsonOf(first.scene.kitSchema, kit, null, "The film's kit"), kitSchema: first.scene.kitSchema.jsonSchema };
 }
 const assetDoc = (a) => {
+    const identity = { ...(a.sha256 === undefined ? {} : { sha256: a.sha256 }), ...(a.prepared === undefined ? {} : { prepared: a.prepared }) };
     switch (a.kind) {
-        case "font": return a.italic ? { kind: "font", name: a.name, source: a.source, italic: a.italic.name } : { kind: "font", name: a.name, source: a.source };
-        case "image": return { kind: "image", name: a.name, source: a.source, maxSize: a.maxSize };
-        case "video": return { kind: "video", name: a.name, source: a.source, maxSize: a.maxSize };
-        case "audio": return { kind: "audio", name: a.name, source: a.source };
+        case "font": return { kind: "font", name: a.name, source: a.source, ...identity, ...(a.italic ? { italic: a.italic.name } : {}) };
+        case "image": return { kind: "image", name: a.name, source: a.source, maxSize: a.maxSize, ...identity };
+        case "video": return { kind: "video", name: a.name, source: a.source, maxSize: a.maxSize, ...identity };
+        case "audio": return { kind: "audio", name: a.name, source: a.source, ...identity };
     }
 };
 /** A film planned with `stableIds` as film.json. `background` is the color as the film wrote it. */

package/dist/doc/plan-doc.d.ts

@@ -33,21 +33,29 @@ export declare const planFilmDoc: (doc: {
         readonly kind: "font";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
         readonly italic?: string | undefined;
     } | {
         readonly kind: "image";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "video";
         readonly name: string;
         readonly source: string;
         readonly maxSize: number;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     } | {
         readonly kind: "audio";
         readonly name: string;
         readonly source: string;
+        readonly sha256?: string | undefined;
+        readonly prepared?: string | undefined;
     })[];
     readonly tracks: readonly {
         readonly id: string;

package/dist/load/host.js

@@ -1,5 +1,5 @@
 import * as film from "@tongue-core/film";
-import { collectAssets } from "@tongue-core/film";
+import { collectAssetsSync } from "@tongue-core/film";
 import * as jsxDev from "@tongue-core/film/jsx-dev-runtime";
 import { Effect, Predicate } from "effect";
 import { LoadError } from "../errors.js";
@@ -27,8 +27,8 @@ export function linkModule(module, bundle, extra = {}) {
 /** Loads and links a bundle, keeping the assets its modules declare while they run. */
 export const linkBundle = Effect.fn("linkBundle")(function* (host, bundle, extra = {}) {
     const module = yield* loadBundle(host, bundle);
-    const { value, assets } = yield* Effect.tryPromise({
-        try: () => collectAssets(async () => linkModule(module, bundle, extra)),
+    const { value, assets } = yield* Effect.try({
+        try: () => collectAssetsSync(() => linkModule(module, bundle, extra)),
         catch: (e) => (e instanceof LoadError ? e : new LoadError({ file: bundle.entry, message: e instanceof Error ? e.message : String(e) })),
     });
     return { exports: value, assets };

package/dist/load/open-build.js

@@ -4,12 +4,18 @@ import { parseBuildDoc } from "../doc/build-doc.js";
 import { parseFilmDoc } from "../doc/check.js";
 import { sha256 } from "../hash.js";
 import { loadScene } from "./scene.js";
+import { isRemoteSource } from "../media/media.js";
 const read = (reader, path) => Effect.tryPromise({ try: () => reader(path), catch: (e) => new LoadError({ file: path, message: `${path} can't be read from the build: ${e instanceof Error ? e.message : String(e)}` }) });
 /** Opens the build `reader` reads. `manifest` is its build.json (another name opens a variant of
  *  the build, such as one scene on its own, whose own film.json it names). */
 export const openBuild = Effect.fn("openBuild")(function* (reader, host, manifestFile = "build.json") {
     const manifest = yield* parseBuildDoc(yield* read(reader, manifestFile));
     const doc = yield* parseFilmDoc(yield* read(reader, manifest.film));
+    for (const asset of doc.assets.filter((asset) => isRemoteSource(asset.source))) {
+        const original = manifest.originals?.find((item) => item.kind === asset.kind && item.name === asset.name);
+        if (!original || original.source !== asset.source || (asset.sha256 !== undefined && asset.sha256 !== original.hash))
+            return yield* new DocError({ problems: [{ path: `assets.${asset.name}`, message: "missing or mismatched pinned original" }], message: `Remote ${asset.kind} "${asset.name}" needs a matching pinned original in build.json.` });
+    }
     const scenes = new Map();
     for (const entry of doc.scenes) {
         const code = yield* read(reader, entry.bundle);

package/dist/media/media.d.ts

@@ -0,0 +1,67 @@
+import { Effect, Schema } from "effect";
+/** Media identity is independent of its location and of the asset's name in a film. */
+export declare const MediaHash: Schema.String;
+export declare const MediaKind: Schema.Literals<readonly ["font", "image", "audio", "video"]>;
+export declare const MediaUrl: Schema.String;
+export declare const MediaPath: Schema.String;
+export declare const MediaOriginal: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["font", "image", "audio", "video"]>;
+    readonly name: Schema.String;
+    readonly source: Schema.String;
+    readonly hash: Schema.String;
+    readonly bytes: Schema.Int;
+}>;
+export type MediaOriginal = typeof MediaOriginal.Type;
+/** Paths use the canonical asset name "asset"; a project binds them to its own asset names. */
+export declare const PreparedFile: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly hash: Schema.String;
+    readonly bytes: Schema.Int;
+    readonly url: Schema.String;
+}>;
+export declare const PreparedMedia: Schema.Struct<{
+    readonly format: Schema.Literal<"tongue.media">;
+    readonly version: Schema.Literal<1>;
+    readonly kind: Schema.Literals<readonly ["font", "image", "audio", "video"]>;
+    readonly source: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly hash: Schema.String;
+        readonly bytes: Schema.Int;
+    }>;
+    readonly duration: Schema.optionalKey<Schema.Finite>;
+    /** Import recipe version and sizing, so incompatible previews are never reused. */
+    readonly recipe: Schema.String;
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly hash: Schema.String;
+        readonly bytes: Schema.Int;
+        readonly url: Schema.String;
+    }>>;
+}>;
+export type PreparedMedia = typeof PreparedMedia.Type;
+declare const MediaFailure_base: Schema.Class<MediaFailure, Schema.TaggedStruct<"MediaFailure", {
+    readonly asset: Schema.String;
+    readonly source: Schema.String;
+    readonly reason: Schema.Literals<readonly ["network", "http", "integrity", "invalid", "storage"]>;
+    readonly status: Schema.optionalKey<Schema.Number>;
+    readonly retryable: Schema.Boolean;
+    readonly message: Schema.String;
+    readonly retryAfterMs: Schema.optionalKey<Schema.Number>;
+}>, import("effect/Cause").YieldableError>;
+export declare class MediaFailure extends MediaFailure_base {
+}
+export interface MediaRequestOptions {
+    /** A host can refresh signed URLs or supply authorization here. Never serialized into a build. */
+    readonly request?: (url: string, signal: AbortSignal, headers?: Readonly<Record<string, string>>) => Promise<Response>;
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Retries after the first attempt. Default 2. */
+    readonly retries?: number;
+    readonly timeoutMs?: number;
+    readonly retryDelayMs?: number;
+}
+export declare const isRemoteSource: (source: string) => boolean;
+/** The response body is consumed inside the retry boundary, including interrupted transfers. */
+export declare const readMedia: <A>(asset: string, url: string, consume: (response: Response, signal: AbortSignal) => Promise<A>, options?: MediaRequestOptions) => Effect.Effect<A, MediaFailure>;
+/** Shared virtual path binding keeps the engine independent of URLs and storage. */
+export declare function bindMediaPath(path: string, kind: string, name: string): string;
+export {};

package/dist/media/media.js

@@ -0,0 +1,76 @@
+import { Effect, Schema } from "effect";
+/** Media identity is independent of its location and of the asset's name in a film. */
+export const MediaHash = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/));
+export const MediaKind = Schema.Literals(["font", "image", "audio", "video"]);
+export const MediaUrl = Schema.String.check(Schema.makeFilter((value) => {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "https:" || url.protocol === "http:") && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+}));
+export const MediaPath = Schema.String.check(Schema.makeFilter((value) => value.length > 0 && !value.startsWith("/") && !value.includes("\\") && value.split("/").every((part) => part !== ".." && part !== "." && part.length > 0)));
+export const MediaOriginal = Schema.Struct({
+    kind: MediaKind, name: Schema.String, source: MediaUrl, hash: MediaHash,
+    bytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+});
+/** Paths use the canonical asset name "asset"; a project binds them to its own asset names. */
+export const PreparedFile = Schema.Struct({
+    path: MediaPath, hash: MediaHash, bytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), url: MediaUrl,
+});
+export const PreparedMedia = Schema.Struct({
+    format: Schema.Literal("tongue.media"), version: Schema.Literal(1), kind: MediaKind,
+    source: Schema.Struct({ url: MediaUrl, hash: MediaHash, bytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }),
+    duration: Schema.optionalKey(Schema.Finite.check(Schema.isGreaterThan(0))),
+    /** Import recipe version and sizing, so incompatible previews are never reused. */
+    recipe: Schema.String,
+    files: Schema.Array(PreparedFile),
+});
+export class MediaFailure extends Schema.TaggedError()("MediaFailure", {
+    asset: Schema.String, source: Schema.String,
+    reason: Schema.Literals(["network", "http", "integrity", "invalid", "storage"]),
+    status: Schema.optionalKey(Schema.Number), retryable: Schema.Boolean, message: Schema.String,
+    retryAfterMs: Schema.optionalKey(Schema.Number),
+}) {
+}
+export const isRemoteSource = (source) => /^https?:\/\//i.test(source);
+const message = (error) => error instanceof Error ? error.message : String(error);
+/** The response body is consumed inside the retry boundary, including interrupted transfers. */
+export const readMedia = (asset, url, consume, options = {}) => Effect.gen(function* () {
+    if (!Schema.is(MediaUrl)(url))
+        return yield* new MediaFailure({ asset, source: url, reason: "invalid", retryable: false, message: `${asset}: media requires an absolute HTTP(S) URL without embedded credentials.` });
+    const retries = Math.max(0, Math.min(10, options.retries ?? 2));
+    for (let attempt = 0;; attempt++) {
+        const result = yield* Effect.tryPromise({
+            try: async (signal) => {
+                const abort = AbortSignal.any([signal, AbortSignal.timeout(options.timeoutMs ?? 120_000)]);
+                const response = await (options.request ?? ((source, cancel, headers) => fetch(source, { signal: cancel, headers })))(url, abort, options.headers);
+                if (!response.ok && response.status !== 304) {
+                    await response.body?.cancel();
+                    const retry = response.headers.get("retry-after");
+                    const delay = retry === null ? 0 : /^\d+$/.test(retry) ? Number(retry) * 1000 : Math.max(0, Date.parse(retry) - Date.now());
+                    throw new MediaFailure({ asset, source: url, reason: "http", status: response.status, retryable: response.status === 408 || response.status === 429 || response.status >= 500, ...(Number.isFinite(delay) && delay > 0 ? { retryAfterMs: Math.min(60_000, delay) } : {}), message: `${asset}: ${url} returned HTTP ${response.status}.` });
+                }
+                return consume(response, abort);
+            },
+            catch: (error) => error instanceof MediaFailure ? error : new MediaFailure({ asset, source: url, reason: "network", retryable: true, message: `${asset}: ${url} could not be downloaded: ${message(error)}` }),
+        }).pipe(Effect.result);
+        if (result._tag === "Success")
+            return result.success;
+        if (!result.failure.retryable || attempt >= retries)
+            return yield* result.failure;
+        yield* Effect.sleep(result.failure.retryAfterMs ?? Math.min(5000, (options.retryDelayMs ?? 200) * 2 ** attempt));
+    }
+});
+/** Shared virtual path binding keeps the engine independent of URLs and storage. */
+export function bindMediaPath(path, kind, name) {
+    if (kind === "font")
+        return path.replace(/^fonts\/asset(?=\.)/, `fonts/${name}`);
+    if (kind === "image")
+        return path.replace(/^images\/asset(?=\.)/, `images/${name}`);
+    if (kind === "audio")
+        return path.replace(/^audio\/asset(?=[/.])/, `audio/${name}`);
+    return path.replace(/^video\/asset\//, `video/${name}/`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tongue-core/project",
-  "version": "0.1.0-rc.8",
+  "version": "0.1.0-rc.9",
   "description": "Film projects: their shape, building one into film.json and a bundle per scene, film.json's schema and checks, and turning it back into a film. No Bun, Node or ffmpeg: runs in Bun, browsers and Workers.",
   "type": "module",
   "license": "MIT",
@@ -31,6 +31,10 @@
     "./template": {
       "types": "./dist/template/index.d.ts",
       "default": "./dist/template/index.js"
+    },
+    "./media": {
+      "types": "./dist/media/media.d.ts",
+      "default": "./dist/media/media.js"
     }
   },
   "main": "./dist/index.js",
@@ -40,7 +44,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@tongue-core/film": "0.1.0-rc.8",
+    "@tongue-core/film": "0.1.0-rc.9",
     "sucrase": "3.35.1"
   },
   "peerDependencies": {