Skip to content

armgit / hypit

Public Imported from GitHub
0

Clone any viral video with AI agents. Not just a script, the whole workflow: swap the face, the words, the B-roll, ship 100 variants in one command, and get your 100M views.

fix(result): decode stored result data at repository boundary

kashorinf8fca3af0b51
diff --git a/packages/build-result-s3/src/repository.ts b/packages/build-result-s3/src/repository.ts
index b0b630df..c24e0a0f 100644
--- a/packages/build-result-s3/src/repository.ts
+++ b/packages/build-result-s3/src/repository.ts
@@ -2,7 +2,6 @@ import type {
BuildResultFileRef,
BuildResultFileRange,
BuildResultFinish,
- BuildResultValueDocument,
BuildResultManifest,
BuildResultPresentationUpdate,
BuildResultRepository,
@@ -14,8 +13,12 @@ import type {
} from "@hypit/build-result";
import {
applyBuildResultPresentation,
- assertBuildResultValueDocument,
assertBuildResultSeed,
+ decodeBuildResultJson,
+ decodeBuildResultManifest,
+ decodeBuildResultValueDocument,
+ decodeBuildResultWriterState,
+ encodeBuildResultManifest,
syncBuildResultOutputs,
} from "@hypit/build-result";
import { assertOrderedBuildId, buildIdCreatedAt } from "@hypit/protocol";
@@ -62,14 +65,6 @@ function encodeJson(value: unknown): Uint8Array {
return new TextEncoder().encode(`${JSON.stringify(value, null, 2)}\n`);
}
-function decodeJson<T>(value: Uint8Array, subject: string): T {
- try {
- return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(value)) as T;
- } catch (error) {
- throw new Error(`${subject} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
- }
-}
-
class S3BuildResultWriter implements BuildResultWriter {
readonly #repository: S3BuildResultRepository;
readonly #build: string;
@@ -146,9 +141,9 @@ export class S3BuildResultRepository implements BuildResultRepository {
return this.#prefix.length === 0 ? relative : `${this.#prefix}/${relative}`;
}
- async #readJson<T>(build: string, path: string): Promise<T | undefined> {
+ async #readJson(build: string, path: string): Promise<unknown | undefined> {
const bytes = await this.#client.get(this.#key(build, path));
- return bytes === undefined ? undefined : decodeJson<T>(bytes, `${build}/${path}`);
+ return bytes === undefined ? undefined : decodeBuildResultJson(bytes, `${build}/${path}`);
}
async writeJson(build: string, path: string, value: unknown): Promise<void> {
@@ -160,11 +155,13 @@ export class S3BuildResultRepository implements BuildResultRepository {
}
async writeManifest(build: string, manifest: BuildResultManifest): Promise<void> {
- await this.writeJson(build, "result.json", manifest);
+ await this.writeJson(build, "result.json", encodeBuildResultManifest(manifest));
}
async readWriter(build: string): Promise<BuildResultWriterState | undefined> {
- return await this.#readJson<BuildResultWriterState>(build, ".writer.json");
+ const subject = `${build}/.writer.json`;
+ const value = await this.#readJson(build, ".writer.json");
+ return value === undefined ? undefined : decodeBuildResultWriterState(value, subject);
}
async writeWriter(build: string, state: BuildResultWriterState): Promise<void> {
@@ -219,9 +216,9 @@ export class S3BuildResultRepository implements BuildResultRepository {
}
async read(build: string): Promise<BuildResultManifest | undefined> {
- const manifest = await this.#readJson<BuildResultManifest>(build, "result.json");
- if (manifest !== undefined) assert(manifest.format === "hypit.build-result@2", `${build}/result.json is not a Build Result`);
- return manifest;
+ const subject = `${build}/result.json`;
+ const value = await this.#readJson(build, "result.json");
+ return value === undefined ? undefined : decodeBuildResultManifest(value, build, subject);
}
async updatePresentation(
@@ -286,9 +283,12 @@ export class S3BuildResultRepository implements BuildResultRepository {
continue;
}
if (entry.value.kind === "value") {
- const document = await this.#readJson<BuildResultValueDocument>(currentBuild, entry.value.path);
- assert(document !== undefined, `Build ${currentBuild} value ${entry.value.path} is unavailable`);
- assertBuildResultValueDocument(document, `Build ${currentBuild} Output ${currentOutput}`);
+ const rawDocument = await this.#readJson(currentBuild, entry.value.path);
+ assert(rawDocument !== undefined, `Build ${currentBuild} value ${entry.value.path} is unavailable`);
+ const document = decodeBuildResultValueDocument(
+ rawDocument,
+ `Build ${currentBuild} Output ${currentOutput}`,
+ );
return {
build: currentBuild,
output: currentOutput,
diff --git a/packages/build-result-s3/test/repository.test.ts b/packages/build-result-s3/test/repository.test.ts
index fbed95a6..96243eae 100644
--- a/packages/build-result-s3/test/repository.test.ts
+++ b/packages/build-result-s3/test/repository.test.ts
@@ -123,6 +123,11 @@ test("S3 keeps the same Build Result model as the filesystem repository", async
{ name: "shot.video", output: "logical:video" },
],
});
+ const storedManifestKey = [...client.objects.keys()].find((key) => key.endsWith("/result.json"));
+ assert.notEqual(storedManifestKey, undefined);
+ const storedManifest = JSON.parse(new TextDecoder().decode(client.objects.get(storedManifestKey!)!)) as object;
+ assert.equal(Object.hasOwn(storedManifest, "id"), false);
+ assert.equal((await writer.read()).id, "bld_20260902T100000000Z_0000000001");
const manifest = await writer.sync({
state: state({
records: [
@@ -220,6 +225,20 @@ test("S3 opens only the requested byte range of a Result file", async () => {
assert.equal(new TextDecoder().decode(Uint8Array.from(chunks)), "2345");
});
+test("S3 uses the shared Result decoder before exposing a manifest", async () => {
+ const client = new MemoryS3();
+ const repository = new S3BuildResultRepository({ bucket: "unused", client });
+ const build = "bld_20260902T100000012Z_0000000001";
+ const physical = `${(Number.MAX_SAFE_INTEGER - Date.parse("2026-09-02T10:00:00.012Z")).toString().padStart(16, "0")}-${build}`;
+ client.objects.set(`${physical}/result.json`, new TextEncoder().encode(JSON.stringify({
+ format: "hypit.build-result@2",
+ source: { path: "main.svml" },
+ targets: [],
+ outputs: null,
+ })));
+ await assert.rejects(repository.read(build), /result\.json\.outputs must be an object/u);
+});
+
test("S3 diagnosis performs one bounded prefix listing", async () => {
const client = new MemoryS3();
const repository = new S3BuildResultRepository({
diff --git a/packages/build-result/src/decode.ts b/packages/build-result/src/decode.ts
new file mode 100644
index 00000000..7c6122a9
--- /dev/null
+++ b/packages/build-result/src/decode.ts
@@ -0,0 +1,236 @@
+import { assertOrderedBuildId } from "@hypit/protocol";
+import type { TypeRef } from "@hypit/protocol";
+
+import {
+ assertBuildResultFileRef,
+ assertBuildResultPath,
+ assertBuildResultValueDocument,
+} from "./types.js";
+import type {
+ BuildResultManifest,
+ BuildResultOutput,
+ BuildResultOutputValue,
+ BuildResultValueDocument,
+} from "./types.js";
+import type { BuildResultWriterState } from "./writer.js";
+
+function object(value: unknown, subject: string): Readonly<Record<string, unknown>> {
+ if (value === null || Array.isArray(value) || typeof value !== "object") {
+ throw new Error(`${subject} must be an object`);
+ }
+ return value as Readonly<Record<string, unknown>>;
+}
+
+function text(value: unknown, subject: string): string {
+ if (typeof value !== "string" || value.length === 0) throw new Error(`${subject} must be a non-empty string`);
+ return value;
+}
+
+function optionalText(value: unknown, subject: string): string | undefined {
+ return value === undefined ? undefined : text(value, subject);
+}
+
+function optionalString(value: unknown, subject: string): string | undefined {
+ if (value === undefined) return undefined;
+ if (typeof value !== "string") throw new Error(`${subject} must be a string`);
+ return value;
+}
+
+function texts(value: unknown, subject: string): readonly string[] {
+ if (!Array.isArray(value)) throw new Error(`${subject} must be an array`);
+ return value.map((item, index) => text(item, `${subject}[${index}]`));
+}
+
+function buildId(value: unknown, subject: string): string {
+ const id = text(value, subject);
+ try {
+ assertOrderedBuildId(id);
+ } catch (error) {
+ throw new Error(`${subject} is invalid: ${error instanceof Error ? error.message : String(error)}`);
+ }
+ return id;
+}
+
+function typeRef(value: unknown, subject: string): TypeRef {
+ const item = object(value, subject);
+ const module = object(item.module, `${subject}.module`);
+ return {
+ module: {
+ name: text(module.name, `${subject}.module.name`),
+ version: text(module.version, `${subject}.module.version`),
+ },
+ name: text(item.name, `${subject}.name`),
+ };
+}
+
+function resultPath(value: unknown, subject: string): string {
+ assertBuildResultPath(value, subject);
+ return value;
+}
+
+function outputValue(value: unknown, subject: string): BuildResultOutputValue {
+ const item = object(value, subject);
+ if (item.kind === "build-file") {
+ assertBuildResultFileRef(item, subject);
+ return {
+ kind: "build-file",
+ path: item.path,
+ size: item.size,
+ mediaType: item.mediaType,
+ };
+ }
+ if (item.kind === "build-output") {
+ return {
+ kind: "build-output",
+ build: buildId(item.build, `${subject}.build`),
+ output: text(item.output, `${subject}.output`),
+ };
+ }
+ if (item.kind === "inline") {
+ const scalar = item.value;
+ if (scalar !== null && typeof scalar !== "boolean" && typeof scalar !== "string"
+ && !(typeof scalar === "number" && Number.isFinite(scalar))) {
+ throw new Error(`${subject}.value must be a scalar`);
+ }
+ return { kind: "inline", value: scalar };
+ }
+ if (item.kind === "value") {
+ return { kind: "value", path: resultPath(item.path, `${subject}.path`) };
+ }
+ throw new Error(`${subject}.kind is not a Result value kind`);
+}
+
+function outputs(value: unknown, subject: string): Readonly<Record<string, BuildResultOutput>> {
+ const raw = object(value, subject);
+ return Object.fromEntries(Object.entries(raw).map(([name, value]) => {
+ text(name, `${subject} Output name`);
+ const item = object(value, `${subject}[${JSON.stringify(name)}]`);
+ return [name, {
+ type: typeRef(item.type, `${subject}[${JSON.stringify(name)}].type`),
+ value: outputValue(item.value, `${subject}[${JSON.stringify(name)}].value`),
+ }] as const;
+ }));
+}
+
+function optionalTime(value: unknown, subject: string): number | undefined {
+ if (value === undefined) return undefined;
+ if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+ throw new Error(`${subject} must be a non-negative integer timestamp`);
+ }
+ return value;
+}
+
+/** Decode JSON bytes without letting invalid UTF-8 or an anonymous SyntaxError escape the Result boundary. */
+export function decodeBuildResultJson(value: Uint8Array, subject: string): unknown {
+ try {
+ return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(value)) as unknown;
+ } catch (error) {
+ throw new Error(`${subject} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+ }
+}
+
+/** Decode one Result document and attach the Build identity supplied by its repository address. */
+export function decodeBuildResultManifest(
+ value: unknown,
+ build: string,
+ subject = `Build ${build} result.json`,
+): BuildResultManifest {
+ const id = buildId(build, "Build Result address");
+ const item = object(value, subject);
+ if (item.format !== "hypit.build-result@2") throw new Error(`${subject} is not a Hypit Build Result`);
+ const source = object(item.source, `${subject}.source`);
+ const run = item.run === undefined ? undefined : object(item.run, `${subject}.run`);
+ const title = optionalText(item.title, `${subject}.title`);
+ const note = optionalText(item.note, `${subject}.note`);
+ const highlightedOutputs = item.highlightedOutputs === undefined
+ ? undefined
+ : texts(item.highlightedOutputs, `${subject}.highlightedOutputs`);
+ const finishedAt = optionalTime(item.finishedAt, `${subject}.finishedAt`);
+ let outcome: BuildResultManifest["outcome"];
+ if (item.outcome !== undefined) {
+ if (item.outcome !== "complete" && item.outcome !== "failed" && item.outcome !== "cancelled") {
+ throw new Error(`${subject}.outcome is not a Build Result outcome`);
+ }
+ outcome = item.outcome;
+ }
+ if ((outcome === undefined) !== (finishedAt === undefined)) {
+ throw new Error(`${subject} must be either unfinished or have both outcome and finishedAt`);
+ }
+ const failure = optionalString(item.failure, `${subject}.failure`);
+ return {
+ format: "hypit.build-result@2",
+ id,
+ ...(title === undefined ? {} : { title }),
+ ...(note === undefined ? {} : { note }),
+ ...(highlightedOutputs === undefined ? {} : { highlightedOutputs }),
+ source: { path: text(source.path, `${subject}.source.path`) },
+ ...(run === undefined ? {} : { run: { path: text(run.path, `${subject}.run.path`) } }),
+ targets: texts(item.targets, `${subject}.targets`),
+ ...(finishedAt === undefined ? {} : { finishedAt }),
+ ...(outcome === undefined ? {} : { outcome }),
+ ...(failure === undefined ? {} : { failure }),
+ outputs: outputs(item.outputs, `${subject}.outputs`),
+ };
+}
+
+/** Persist only Result content. The repository address is the single Build identity. */
+export function encodeBuildResultManifest(manifest: BuildResultManifest): Omit<BuildResultManifest, "id"> {
+ const { id: _id, ...document } = manifest;
+ return document;
+}
+
+function pathMap(value: unknown, subject: string): Readonly<Record<string, string>> {
+ const item = object(value, subject);
+ return Object.fromEntries(Object.entries(item).map(([identity, path]) => [
+ text(identity, `${subject} identity`),
+ resultPath(path, `${subject}[${JSON.stringify(identity)}]`),
+ ]));
+}
+
+/** Decode the private, unfinished-Result writer state used by both physical repositories. */
+export function decodeBuildResultWriterState(
+ value: unknown,
+ subject = "Build Result writer state",
+): BuildResultWriterState {
+ const item = object(value, subject);
+ if (!Array.isArray(item.publishedOutputs)) throw new Error(`${subject}.publishedOutputs must be an array`);
+ if (!Array.isArray(item.forwards)) throw new Error(`${subject}.forwards must be an array`);
+ const names = new Set<string>();
+ const logicalOutputs = new Set<string>();
+ const publishedOutputs = item.publishedOutputs.map((value, index) => {
+ const published = object(value, `${subject}.publishedOutputs[${index}]`);
+ const name = text(published.name, `${subject}.publishedOutputs[${index}].name`);
+ const output = text(published.output, `${subject}.publishedOutputs[${index}].output`);
+ if (names.has(name)) throw new Error(`${subject} repeats published name ${name}`);
+ if (logicalOutputs.has(output)) throw new Error(`${subject} publishes Logical Output ${output} more than once`);
+ names.add(name);
+ logicalOutputs.add(output);
+ return { name, output };
+ });
+ const forwardedOutputs = new Set<string>();
+ const forwards = item.forwards.map((value, index) => {
+ const forward = object(value, `${subject}.forwards[${index}]`);
+ const output = text(forward.output, `${subject}.forwards[${index}].output`);
+ if (forwardedOutputs.has(output)) throw new Error(`${subject} forwards Logical Output ${output} more than once`);
+ forwardedOutputs.add(output);
+ return {
+ output,
+ build: buildId(forward.build, `${subject}.forwards[${index}].build`),
+ sourceOutput: text(forward.sourceOutput, `${subject}.forwards[${index}].sourceOutput`),
+ };
+ });
+ return {
+ resources: pathMap(item.resources, `${subject}.resources`),
+ values: pathMap(item.values, `${subject}.values`),
+ publishedOutputs,
+ forwards,
+ };
+}
+
+export function decodeBuildResultValueDocument(
+ value: unknown,
+ subject = "Build Result value",
+): BuildResultValueDocument {
+ assertBuildResultValueDocument(value, subject);
+ return value;
+}
diff --git a/packages/build-result/src/index.ts b/packages/build-result/src/index.ts
index 22a2b6e8..c4b2f818 100644
--- a/packages/build-result/src/index.ts
+++ b/packages/build-result/src/index.ts
@@ -2,6 +2,13 @@ export {
assertBuildResultValueDocument,
assertBuildResultSeed,
} from "./types.js";
+export {
+ decodeBuildResultJson,
+ decodeBuildResultManifest,
+ decodeBuildResultValueDocument,
+ decodeBuildResultWriterState,
+ encodeBuildResultManifest,
+} from "./decode.js";
export { syncBuildResultOutputs } from "./writer.js";
export {
FileBuildResult,
diff --git a/packages/build-result/src/store.ts b/packages/build-result/src/store.ts
index 4da7181f..e6f72094 100644
--- a/packages/build-result/src/store.ts
+++ b/packages/build-result/src/store.ts
@@ -11,13 +11,12 @@ import {
writeFile,
} from "node:fs/promises";
import { createReadStream } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
import { assertBuildId, assertOrderedBuildId, buildIdCreatedAt } from "@hypit/protocol";
import type { BlobRef } from "@hypit/protocol";
import type {
- BuildResultValueDocument,
BuildResultResourceSource,
BuildResultFileRef,
BuildResultFileRange,
@@ -31,9 +30,15 @@ import type {
RepositoryBuildResultOutput,
FinishedBuildResultManifest,
} from "./types.js";
-import { assertBuildResultValueDocument, assertBuildResultSeed } from "./types.js";
+import { assertBuildResultSeed } from "./types.js";
+import {
+ decodeBuildResultJson,
+ decodeBuildResultManifest,
+ decodeBuildResultValueDocument,
+ decodeBuildResultWriterState,
+ encodeBuildResultManifest,
+} from "./decode.js";
import { syncBuildResultOutputs } from "./writer.js";
-import type { BuildResultWriterState } from "./writer.js";
const manifestName = "result.json";
const writerStateName = ".writer.json";
@@ -96,6 +101,10 @@ async function writeJsonAtomic(path: string, value: unknown): Promise<void> {
}
}
+async function writeManifestAtomic(path: string, manifest: BuildResultManifest): Promise<void> {
+ await writeJsonAtomic(path, encodeBuildResultManifest(manifest));
+}
+
async function copyArtifactAtomic(
source: BuildResultResourceSource,
artifact: BlobRef,
@@ -133,14 +142,13 @@ export function buildResultDirectory(root: string, build: string): string {
export async function readBuildResult(directory: string): Promise<BuildResultManifest | undefined> {
const path = join(resolve(directory), manifestName);
- const text = await readFile(path, "utf8").catch((error: unknown) => {
+ const bytes = await readFile(path).catch((error: unknown) => {
if (error instanceof Error && "code" in error && error.code === "ENOENT") return undefined;
throw error;
});
- if (text === undefined) return undefined;
- const value = JSON.parse(text) as BuildResultManifest;
- assert(value.format === "hypit.build-result@2", `${path} is not a Hypit Build Result`);
- return value;
+ if (bytes === undefined) return undefined;
+ const build = basename(resolve(directory));
+ return decodeBuildResultManifest(decodeBuildResultJson(bytes, path), build, path);
}
function containedResultPath(directory: string, path: string): string {
@@ -207,10 +215,11 @@ export async function resolveBuildResultOutput(
continue;
}
if (entry.value.kind === "value") {
- const document = JSON.parse(
- await readFile(containedResultPath(directory, entry.value.path), "utf8"),
- ) as BuildResultValueDocument;
- assertBuildResultValueDocument(document, `Build ${currentBuild} Output ${currentOutput}`);
+ const path = containedResultPath(directory, entry.value.path);
+ const document = decodeBuildResultValueDocument(
+ decodeBuildResultJson(await readFile(path), path),
+ `Build ${currentBuild} Output ${currentOutput}`,
+ );
return {
build: currentBuild,
output: currentOutput,
@@ -343,7 +352,7 @@ export class FileBuildResult {
outputs: {},
};
try {
- await writeJsonAtomic(join(temporary, manifestName), manifest);
+ await writeManifestAtomic(join(temporary, manifestName), manifest);
await writeJsonAtomic(join(temporary, writerStateName), {
resources: {},
values: {},
@@ -374,8 +383,11 @@ export class FileBuildResult {
async sync(input: BuildResultSync): Promise<BuildResultManifest> {
const manifest = await this.read();
if (manifest.outcome !== undefined) return manifest;
- const rawWriter = await readFile(join(this.directory, writerStateName), "utf8");
- const writer = JSON.parse(rawWriter) as BuildResultWriterState;
+ const writerPath = join(this.directory, writerStateName);
+ const writer = decodeBuildResultWriterState(
+ decodeBuildResultJson(await readFile(writerPath), writerPath),
+ writerPath,
+ );
const directory = this.directory;
const updated = await syncBuildResultOutputs({
manifest,
@@ -391,7 +403,7 @@ export class FileBuildResult {
},
});
await writeJsonAtomic(join(this.directory, writerStateName), updated.writer);
- await writeJsonAtomic(join(this.directory, manifestName), updated.manifest);
+ await writeManifestAtomic(join(this.directory, manifestName), updated.manifest);
return updated.manifest;
}
@@ -410,7 +422,7 @@ export class FileBuildResult {
finishedAt: manifest.finishedAt ?? now,
...(input.failure === undefined ? {} : { failure: input.failure }),
};
- await writeJsonAtomic(join(this.directory, manifestName), updated);
+ await writeManifestAtomic(join(this.directory, manifestName), updated);
await rm(join(this.directory, writerStateName), { force: true });
return updated;
}
@@ -449,7 +461,7 @@ export class FileBuildResultRepository implements BuildResultRepository {
const manifest = await this.read(build);
assert(manifest !== undefined, `Build Result ${build} does not exist`);
const updated = applyBuildResultPresentation(manifest, update);
- await writeJsonAtomic(join(buildResultDirectory(this.root, build), manifestName), updated);
+ await writeManifestAtomic(join(buildResultDirectory(this.root, build), manifestName), updated);
return updated;
}
diff --git a/packages/build-result/src/types.ts b/packages/build-result/src/types.ts
index e1e7efb8..23447f25 100644
--- a/packages/build-result/src/types.ts
+++ b/packages/build-result/src/types.ts
@@ -63,16 +63,26 @@ function assertCanonicalValue(value: unknown, subject: string): asserts value is
}
}
-function assertBuildResultFileRef(value: unknown, subject: string): asserts value is BuildResultFileRef {
+/** One portable address inside a Build Result; repositories map it to their own physical storage. */
+export function assertBuildResultPath(value: unknown, subject: string): asserts value is string {
+ if (typeof value !== "string" || value.length === 0 || value.startsWith("/")
+ || value.includes("\\") || value.includes("\0")
+ || value.split("/").some((part) => part.length === 0 || part === "." || part === "..")) {
+ throw new Error(`${subject} is not a Result-relative path`);
+ }
+}
+
+export function assertBuildResultFileRef(value: unknown, subject: string): asserts value is BuildResultFileRef {
if (value === null || Array.isArray(value) || typeof value !== "object") {
throw new Error(`${subject} is not a Build file reference`);
}
const item = value as Readonly<Record<string, unknown>>;
- if (item.kind !== "build-file" || typeof item.path !== "string" || item.path.length === 0
+ if (item.kind !== "build-file"
|| typeof item.size !== "number" || !Number.isSafeInteger(item.size) || item.size < 0
|| typeof item.mediaType !== "string" || item.mediaType.length === 0) {
throw new Error(`${subject} is not a valid Build file reference`);
}
+ assertBuildResultPath(item.path, `${subject}.path`);
}
function valueAtPath(value: CanonicalValue, path: BuildResultValuePath, subject: string): CanonicalValue {
@@ -146,6 +156,7 @@ export type BuildResultOutput = {
export type BuildResultManifest = {
readonly format: "hypit.build-result@2";
+ /** Injected from the Repository address; `result.json` does not repeat its containing Build id. */
readonly id: string;
readonly title?: string;
readonly note?: string;
diff --git a/packages/build-result/test/result.test.ts b/packages/build-result/test/result.test.ts
index 7f6b4571..f46b2f65 100644
--- a/packages/build-result/test/result.test.ts
+++ b/packages/build-result/test/result.test.ts
@@ -55,6 +55,9 @@ test("one same-Build resource backs a public video and a SemanticTake payload",
{ name: "unused.video", output: "logical:unused" },
],
});
+ const storedManifest = JSON.parse(await readFile(join(result.directory, "result.json"), "utf8")) as object;
+ assert.equal(Object.hasOwn(storedManifest, "id"), false);
+ assert.equal((await result.read()).id, "bld_20260902T100000000Z_0000000001");
const manifest = await result.sync({
state: state({
records: [
@@ -164,6 +167,48 @@ test("filesystem repository streams one normalized byte range", async () => {
}
});
+test("filesystem decodes Result and writer data before exposing it", async () => {
+ const root = await mkdtemp(join(tmpdir(), "hypit-result-decode-"));
+ const malformed = "bld_20260902T100000010Z_0000000001";
+ const unfinished = "bld_20260902T100000011Z_0000000001";
+ try {
+ const directory = join(root, malformed);
+ await mkdir(directory, { recursive: true });
+ await writeFile(join(directory, "result.json"), JSON.stringify({
+ format: "hypit.build-result@2",
+ source: { path: "main.svml" },
+ targets: ["video"],
+ outputs: {
+ video: {
+ type: videoType,
+ value: { kind: "build-file", path: "../outside.mp4", size: 1, mediaType: "video/mp4" },
+ },
+ },
+ }));
+ const repository = new FileBuildResultRepository(root);
+ await assert.rejects(repository.read(malformed), /outputs\["video"\]\.value\.path is not a Result-relative path/u);
+
+ const writer = await repository.create({
+ id: unfinished,
+ source: { path: "main.svml" },
+ targets: [],
+ publishedOutputs: [],
+ });
+ await writeFile(join(root, unfinished, ".writer.json"), JSON.stringify({
+ resources: null,
+ values: {},
+ publishedOutputs: [],
+ forwards: [],
+ }));
+ await assert.rejects(writer.sync({
+ state: state({ records: [], bindings: [] }),
+ resources: { async open() { return undefined; } },
+ }), /\.writer\.json\.resources must be an object/u);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+});
+
test("reserved-looking domain objects remain ordinary Composite data", async () => {
const root = await mkdtemp(join(tmpdir(), "hypit-result-json-reference-"));
const id = "bld_20260902T100000000Z_0000000001";
@@ -172,7 +217,6 @@ test("reserved-looking domain objects remain ordinary Composite data", async ()
await mkdir(join(directory, "values"), { recursive: true });
await writeFile(join(directory, "result.json"), JSON.stringify({
format: "hypit.build-result@2",
- id,
source: { path: "main.svml" },
targets: ["value"],
outcome: "complete",
diff --git a/packages/studio/test/build-library.test.ts b/packages/studio/test/build-library.test.ts
index f578c297..86a14c35 100644
--- a/packages/studio/test/build-library.test.ts
+++ b/packages/studio/test/build-library.test.ts
@@ -106,7 +106,6 @@ test("Studio opens project Build Results without a Runtime or ResourceStore", as
await writeFile(join(directory, "files", "final.mp4"), bytes);
await writeFile(join(directory, "result.json"), `${JSON.stringify({
format: "hypit.build-result@2",
- id: build,
title: "First cut",
source: { path: join(root, "main.svml") },
run: { path: join(root, "build.svrun") },