@dreamboard-games/sdk 0.4.0-alpha.7 → 0.4.0-alpha.9

package/dist/reference-game-compiler.d.ts

@@ -0,0 +1,45 @@
+import { k as ReferenceGameSourceProvenance, h as ReferenceGameSourceManifest } from './schema-9jZzlEWZ.js';
+import 'zod';
+
+declare const CANONICAL_REFERENCE_GAME_IDS: readonly string[];
+
+type ReferenceGameSourceInventoryPolicy = {
+  readonly schemaVersion: 1;
+  readonly workspaceOwnershipVersion: number;
+  readonly excludedGameRelativePaths: readonly string[];
+  readonly excludedGameRelativePrefixes: readonly string[];
+};
+
+type ReferenceGameSourcePathClass =
+  | "included"
+  | "workspace-generated"
+  | "test-generated"
+  | "test-base"
+  | "obsolete-screenshot"
+  | "derived-output";
+
+declare function referenceGamePathIdentity(repositoryPath: string): {
+  readonly gameId: string;
+  readonly relativePath: string;
+} | null;
+
+declare const REFERENCE_GAME_SOURCE_INVENTORY_POLICY: ReferenceGameSourceInventoryPolicy;
+
+declare function classifyReferenceGameSourcePath(repositoryPath: string): ReferenceGameSourcePathClass;
+declare function isReferenceGameSourceObject(repositoryPath: string): boolean;
+declare function shouldDescendIntoReferenceGameDirectory(repositoryPath: string): boolean;
+
+declare function collectReferenceGameSourceManifest(options: {
+    readonly sourceRoot: string;
+    readonly provenance: ReferenceGameSourceProvenance;
+}): Promise<ReferenceGameSourceManifest>;
+declare function collectReferenceGameSourceObjects(options: {
+    readonly referenceGamesRoot: string;
+    readonly sourceRoot: string;
+}): Promise<Array<{
+    readonly path: string;
+    readonly sha256: string;
+    readonly byteLength: number;
+}>>;
+
+export { CANONICAL_REFERENCE_GAME_IDS, REFERENCE_GAME_SOURCE_INVENTORY_POLICY, type ReferenceGameSourcePathClass, classifyReferenceGameSourcePath, collectReferenceGameSourceManifest, collectReferenceGameSourceObjects, isReferenceGameSourceObject, referenceGamePathIdentity, shouldDescendIntoReferenceGameDirectory };

package/dist/reference-game-compiler.js

@@ -0,0 +1,25 @@
+import {
+  CANONICAL_REFERENCE_GAME_IDS,
+  REFERENCE_GAME_SOURCE_INVENTORY_POLICY,
+  classifyReferenceGameSourcePath,
+  collectReferenceGameSourceManifest,
+  collectReferenceGameSourceObjects,
+  isReferenceGameSourceObject,
+  referenceGamePathIdentity,
+  shouldDescendIntoReferenceGameDirectory
+} from "./chunk-XLHLFTLI.js";
+import "./chunk-45P5CEGH.js";
+import "./chunk-UNVCT5Z7.js";
+import "./chunk-SACZWUA6.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  CANONICAL_REFERENCE_GAME_IDS,
+  REFERENCE_GAME_SOURCE_INVENTORY_POLICY,
+  classifyReferenceGameSourcePath,
+  collectReferenceGameSourceManifest,
+  collectReferenceGameSourceObjects,
+  isReferenceGameSourceObject,
+  referenceGamePathIdentity,
+  shouldDescendIntoReferenceGameDirectory
+};
+//# sourceMappingURL=reference-game-compiler.js.map

package/dist/reference-game-compiler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/reference-game-source-manifest-cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/reference-game-source-manifest-cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  collectReferenceGameSourceManifest
+} from "./chunk-XLHLFTLI.js";
+import "./chunk-45P5CEGH.js";
+import "./chunk-UNVCT5Z7.js";
+import "./chunk-SACZWUA6.js";
+import "./chunk-PZ5AY32C.js";
+
+// src/reference-game-source-manifest-cli.ts
+import { writeFile } from "fs/promises";
+import path from "path";
+var options = parseArgs(process.argv.slice(2));
+var manifest = await collectReferenceGameSourceManifest(options);
+var serialized = `${JSON.stringify(manifest, null, 2)}
+`;
+if (options.out) {
+  await writeFile(path.resolve(options.out), serialized);
+} else {
+  process.stdout.write(serialized);
+}
+function parseArgs(argv) {
+  let sourceRoot;
+  let out;
+  let revision;
+  let repository;
+  let worktree = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--source-root") {
+      sourceRoot = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--out") {
+      out = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--revision") {
+      revision = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--repository") {
+      repository = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg === "--worktree") {
+      worktree = true;
+      continue;
+    }
+    throw new Error(`Unknown argument '${arg}'.`);
+  }
+  if (!sourceRoot) throw new Error("--source-root is required.");
+  if (worktree && (revision || repository)) {
+    throw new Error("--worktree cannot be combined with Git provenance.");
+  }
+  let provenance;
+  if (worktree) {
+    provenance = { kind: "worktree" };
+  } else {
+    if (!revision || !repository) {
+      throw new Error(
+        "Provide --worktree or both --repository and --revision."
+      );
+    }
+    if (repository !== "dreamboard-games/dreamboard-sdk") {
+      throw new Error("--repository must be dreamboard-games/dreamboard-sdk.");
+    }
+    provenance = {
+      kind: "git",
+      repository: "dreamboard-games/dreamboard-sdk",
+      revision
+    };
+  }
+  return {
+    sourceRoot,
+    provenance,
+    ...out === void 0 ? {} : { out }
+  };
+}
+//# sourceMappingURL=reference-game-source-manifest-cli.js.map

package/dist/reference-game-source-manifest-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reference-game-source-manifest-cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\n\nimport { collectReferenceGameSourceManifest } from \"./reference-games/source-collector.js\";\nimport type { ReferenceGameSourceProvenance } from \"./reference-games/schema.js\";\n\nconst options = parseArgs(process.argv.slice(2));\nconst manifest = await collectReferenceGameSourceManifest(options);\nconst serialized = `${JSON.stringify(manifest, null, 2)}\\n`;\nif (options.out) {\n  await writeFile(path.resolve(options.out), serialized);\n} else {\n  process.stdout.write(serialized);\n}\n\nfunction parseArgs(argv: readonly string[]): {\n  readonly sourceRoot: string;\n  readonly provenance: ReferenceGameSourceProvenance;\n  readonly out?: string;\n} {\n  let sourceRoot: string | undefined;\n  let out: string | undefined;\n  let revision: string | undefined;\n  let repository: string | undefined;\n  let worktree = false;\n  for (let index = 0; index < argv.length; index += 1) {\n    const arg = argv[index];\n    if (arg === \"--source-root\") {\n      sourceRoot = argv[index + 1];\n      index += 1;\n      continue;\n    }\n    if (arg === \"--out\") {\n      out = argv[index + 1];\n      index += 1;\n      continue;\n    }\n    if (arg === \"--revision\") {\n      revision = argv[index + 1];\n      index += 1;\n      continue;\n    }\n    if (arg === \"--repository\") {\n      repository = argv[index + 1];\n      index += 1;\n      continue;\n    }\n    if (arg === \"--worktree\") {\n      worktree = true;\n      continue;\n    }\n    throw new Error(`Unknown argument '${arg}'.`);\n  }\n  if (!sourceRoot) throw new Error(\"--source-root is required.\");\n  if (worktree && (revision || repository)) {\n    throw new Error(\"--worktree cannot be combined with Git provenance.\");\n  }\n  let provenance: ReferenceGameSourceProvenance;\n  if (worktree) {\n    provenance = { kind: \"worktree\" };\n  } else {\n    if (!revision || !repository) {\n      throw new Error(\n        \"Provide --worktree or both --repository and --revision.\",\n      );\n    }\n    if (repository !== \"dreamboard-games/dreamboard-sdk\") {\n      throw new Error(\"--repository must be dreamboard-games/dreamboard-sdk.\");\n    }\n    provenance = {\n      kind: \"git\",\n      repository: \"dreamboard-games/dreamboard-sdk\",\n      revision,\n    };\n  }\n  return {\n    sourceRoot,\n    provenance,\n    ...(out === undefined ? {} : { out }),\n  };\n}\n"],"mappings":";;;;;;;;;;AACA,SAAS,iBAAiB;AAC1B,OAAO,UAAU;AAKjB,IAAM,UAAU,UAAU,QAAQ,KAAK,MAAM,CAAC,CAAC;AAC/C,IAAM,WAAW,MAAM,mCAAmC,OAAO;AACjE,IAAM,aAAa,GAAG,KAAK,UAAU,UAAU,MAAM,CAAC,CAAC;AAAA;AACvD,IAAI,QAAQ,KAAK;AACf,QAAM,UAAU,KAAK,QAAQ,QAAQ,GAAG,GAAG,UAAU;AACvD,OAAO;AACL,UAAQ,OAAO,MAAM,UAAU;AACjC;AAEA,SAAS,UAAU,MAIjB;AACA,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI,WAAW;AACf,WAAS,QAAQ,GAAG,QAAQ,KAAK,QAAQ,SAAS,GAAG;AACnD,UAAM,MAAM,KAAK,KAAK;AACtB,QAAI,QAAQ,iBAAiB;AAC3B,mBAAa,KAAK,QAAQ,CAAC;AAC3B,eAAS;AACT;AAAA,IACF;AACA,QAAI,QAAQ,SAAS;AACnB,YAAM,KAAK,QAAQ,CAAC;AACpB,eAAS;AACT;AAAA,IACF;AACA,QAAI,QAAQ,cAAc;AACxB,iBAAW,KAAK,QAAQ,CAAC;AACzB,eAAS;AACT;AAAA,IACF;AACA,QAAI,QAAQ,gBAAgB;AAC1B,mBAAa,KAAK,QAAQ,CAAC;AAC3B,eAAS;AACT;AAAA,IACF;AACA,QAAI,QAAQ,cAAc;AACxB,iBAAW;AACX;AAAA,IACF;AACA,UAAM,IAAI,MAAM,qBAAqB,GAAG,IAAI;AAAA,EAC9C;AACA,MAAI,CAAC,WAAY,OAAM,IAAI,MAAM,4BAA4B;AAC7D,MAAI,aAAa,YAAY,aAAa;AACxC,UAAM,IAAI,MAAM,oDAAoD;AAAA,EACtE;AACA,MAAI;AACJ,MAAI,UAAU;AACZ,iBAAa,EAAE,MAAM,WAAW;AAAA,EAClC,OAAO;AACL,QAAI,CAAC,YAAY,CAAC,YAAY;AAC5B,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,QAAI,eAAe,mCAAmC;AACpD,YAAM,IAAI,MAAM,uDAAuD;AAAA,IACzE;AACA,iBAAa;AAAA,MACX,MAAM;AAAA,MACN,YAAY;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,GAAI,QAAQ,SAAY,CAAC,IAAI,EAAE,IAAI;AAAA,EACrC;AACF;","names":[]}

package/dist/reference-games/index.d.ts

@@ -1,223 +1,13 @@
-import { z } from 'zod';
-
-declare const REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION = 2;
-declare const REFERENCE_GAME_MANIFEST_SCHEMA_VERSION = 3;
-declare const referenceGameSha256DigestSchema: z.ZodString;
-declare const referenceGameSourceObjectSchema: z.ZodObject<{
-    path: z.ZodString;
-    sha256: z.ZodString;
-    byteLength: z.ZodNumber;
-}, z.core.$strict>;
-declare const referenceGameSourceEntrySchema: z.ZodObject<{
-    id: z.ZodString;
-    root: z.ZodString;
-    sourceSha256: z.ZodString;
-    packageJsonSha256: z.ZodString;
-    lockfileSha256: z.ZodString;
-    sdkSpecifier: z.ZodString;
-    manifest: z.ZodString;
-    reducer: z.ZodString;
-    ui: z.ZodString;
-    behaviorScenarios: z.ZodArray<z.ZodString>;
-    uiScenarios: z.ZodArray<z.ZodString>;
-    mechanics: z.ZodArray<z.ZodString>;
-    readFirst: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-declare const referenceGameSourceManifestPayloadSchema: z.ZodObject<{
-    games: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        root: z.ZodString;
-        sourceSha256: z.ZodString;
-        packageJsonSha256: z.ZodString;
-        lockfileSha256: z.ZodString;
-        sdkSpecifier: z.ZodString;
-        manifest: z.ZodString;
-        reducer: z.ZodString;
-        ui: z.ZodString;
-        behaviorScenarios: z.ZodArray<z.ZodString>;
-        uiScenarios: z.ZodArray<z.ZodString>;
-        mechanics: z.ZodArray<z.ZodString>;
-        readFirst: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>>;
-    objects: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        byteLength: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-declare const referenceGameSourceProvenanceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"worktree">;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"git">;
-    repository: z.ZodLiteral<"dreamboard-games/dreamboard-sdk">;
-    revision: z.ZodString;
-}, z.core.$strict>], "kind">;
-declare const referenceGameSourceManifestSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<2>;
-    manifestType: z.ZodLiteral<"dreamboard.reference-game-source">;
-    bundleDigest: z.ZodString;
-    payload: z.ZodObject<{
-        games: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            root: z.ZodString;
-            sourceSha256: z.ZodString;
-            packageJsonSha256: z.ZodString;
-            lockfileSha256: z.ZodString;
-            sdkSpecifier: z.ZodString;
-            manifest: z.ZodString;
-            reducer: z.ZodString;
-            ui: z.ZodString;
-            behaviorScenarios: z.ZodArray<z.ZodString>;
-            uiScenarios: z.ZodArray<z.ZodString>;
-            mechanics: z.ZodArray<z.ZodString>;
-            readFirst: z.ZodArray<z.ZodString>;
-        }, z.core.$strict>>;
-        objects: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            byteLength: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-    provenance: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"worktree">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"git">;
-        repository: z.ZodLiteral<"dreamboard-games/dreamboard-sdk">;
-        revision: z.ZodString;
-    }, z.core.$strict>], "kind">;
-}, z.core.$strict>;
-declare const referenceGameWorkspaceSchema: z.ZodObject<{
-    manifest: z.ZodString;
-    reducer: z.ZodString;
-    ui: z.ZodString;
-    behaviorScenarios: z.ZodArray<z.ZodString>;
-    uiScenarios: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-declare const referenceGameTeachingSchema: z.ZodObject<{
-    whatThisTeaches: z.ZodArray<z.ZodString>;
-    whenToCopyThisPattern: z.ZodArray<z.ZodString>;
-    readFirst: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-declare const referenceGameDemoReleaseSchema: z.ZodObject<{
-    slug: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodString;
-    overview: z.ZodString;
-    creator: z.ZodString;
-    minPlayers: z.ZodNumber;
-    maxPlayers: z.ZodNumber;
-    playTimeMinMinutes: z.ZodNumber;
-    playTimeMaxMinutes: z.ZodNumber;
-    difficulty: z.ZodNumber;
-    mechanics: z.ZodArray<z.ZodString>;
-    categories: z.ZodArray<z.ZodString>;
-    heroImageUrl: z.ZodString;
-    estimatedMinutes: z.ZodNumber;
-    demoPlayerCount: z.ZodNumber;
-    screenshot: z.ZodObject<{
-        presets: z.ZodRecord<z.ZodString, z.ZodObject<{
-            viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
-            theme: z.ZodString;
-            stagePadding: z.ZodNumber;
-            frame: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-declare const referenceGameRightsSchema: z.ZodObject<{
-    mechanicsProvenance: z.ZodString;
-    sourceCode: z.ZodString;
-    codeLicense: z.ZodString;
-    ruleText: z.ZodString;
-    artwork: z.ZodString;
-    assetLicenseManifest: z.ZodString;
-    thirdPartyMarks: z.ZodArray<z.ZodString>;
-    reviewStatus: z.ZodLiteral<"approved">;
-    reviewedBy: z.ZodString;
-    reviewedAt: z.ZodString;
-}, z.core.$strict>;
-declare const referenceGameSdkPolicySchema: z.ZodObject<{
-    dependency: z.ZodLiteral<"@dreamboard-games/sdk">;
-    versionPolicy: z.ZodLiteral<"exact">;
-}, z.core.$strict>;
-declare const referenceGameManifestV3Schema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<3>;
-    id: z.ZodString;
-    displayName: z.ZodString;
-    workspace: z.ZodObject<{
-        manifest: z.ZodString;
-        reducer: z.ZodString;
-        ui: z.ZodString;
-        behaviorScenarios: z.ZodArray<z.ZodString>;
-        uiScenarios: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-    teaching: z.ZodObject<{
-        whatThisTeaches: z.ZodArray<z.ZodString>;
-        whenToCopyThisPattern: z.ZodArray<z.ZodString>;
-        readFirst: z.ZodArray<z.ZodString>;
-    }, z.core.$strict>;
-    demoRelease: z.ZodOptional<z.ZodObject<{
-        slug: z.ZodString;
-        name: z.ZodString;
-        description: z.ZodString;
-        overview: z.ZodString;
-        creator: z.ZodString;
-        minPlayers: z.ZodNumber;
-        maxPlayers: z.ZodNumber;
-        playTimeMinMinutes: z.ZodNumber;
-        playTimeMaxMinutes: z.ZodNumber;
-        difficulty: z.ZodNumber;
-        mechanics: z.ZodArray<z.ZodString>;
-        categories: z.ZodArray<z.ZodString>;
-        heroImageUrl: z.ZodString;
-        estimatedMinutes: z.ZodNumber;
-        demoPlayerCount: z.ZodNumber;
-        screenshot: z.ZodObject<{
-            presets: z.ZodRecord<z.ZodString, z.ZodObject<{
-                viewport: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
-                theme: z.ZodString;
-                stagePadding: z.ZodNumber;
-                frame: z.ZodString;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-    }, z.core.$strict>>;
-    mechanics: z.ZodArray<z.ZodString>;
-    uiPatterns: z.ZodArray<z.ZodString>;
-    rights: z.ZodObject<{
-        mechanicsProvenance: z.ZodString;
-        sourceCode: z.ZodString;
-        codeLicense: z.ZodString;
-        ruleText: z.ZodString;
-        artwork: z.ZodString;
-        assetLicenseManifest: z.ZodString;
-        thirdPartyMarks: z.ZodArray<z.ZodString>;
-        reviewStatus: z.ZodLiteral<"approved">;
-        reviewedBy: z.ZodString;
-        reviewedAt: z.ZodString;
-    }, z.core.$strict>;
-    sdk: z.ZodObject<{
-        dependency: z.ZodLiteral<"@dreamboard-games/sdk">;
-        versionPolicy: z.ZodLiteral<"exact">;
-    }, z.core.$strict>;
-}, z.core.$strict>;
-type ReferenceGameSourceObject = z.infer<typeof referenceGameSourceObjectSchema>;
-type ReferenceGameSourceEntry = z.infer<typeof referenceGameSourceEntrySchema>;
-type ReferenceGameSourceManifestPayload = z.infer<typeof referenceGameSourceManifestPayloadSchema>;
-type ReferenceGameSourceProvenance = z.infer<typeof referenceGameSourceProvenanceSchema>;
-type ReferenceGameSourceManifest = z.infer<typeof referenceGameSourceManifestSchema>;
-type ReferenceGameWorkspace = z.infer<typeof referenceGameWorkspaceSchema>;
-type ReferenceGameTeaching = z.infer<typeof referenceGameTeachingSchema>;
-type ReferenceGameDemoRelease = z.infer<typeof referenceGameDemoReleaseSchema>;
-type ReferenceGameRights = z.infer<typeof referenceGameRightsSchema>;
-type ReferenceGameSdkPolicy = z.infer<typeof referenceGameSdkPolicySchema>;
-type ReferenceGameManifestV3 = z.infer<typeof referenceGameManifestV3Schema>;
-declare function parseReferenceGameSourceManifest(value: unknown): ReferenceGameSourceManifest;
-declare function parseReferenceGameManifestV3(value: unknown): ReferenceGameManifestV3;
-declare function isPackageableReferenceGame(game: ReferenceGameManifestV3): boolean;
+import { i as ReferenceGameSourceManifestPayload } from '../schema-9jZzlEWZ.js';
+export { R as REFERENCE_GAME_MANIFEST_SCHEMA_VERSION, a as REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION, b as ReferenceGameDemoRelease, c as ReferenceGameManifestV3, d as ReferenceGameRights, e as ReferenceGameSdkPolicy, f as ReferenceGameSourceEntry, g as ReferenceGameSourceInventoryPolicy, h as ReferenceGameSourceManifest, j as ReferenceGameSourceObject, k as ReferenceGameSourceProvenance, l as ReferenceGameTeaching, m as ReferenceGameWorkspace, n as isPackageableReferenceGame, p as parseReferenceGameManifestV3, o as parseReferenceGameSourceManifest, r as referenceGameDemoReleaseSchema, q as referenceGameManifestV3Schema, s as referenceGameRightsSchema, t as referenceGameSdkPolicySchema, u as referenceGameSha256DigestSchema, v as referenceGameSourceEntrySchema, w as referenceGameSourceInventoryPolicySchema, x as referenceGameSourceManifestPayloadSchema, y as referenceGameSourceManifestSchema, z as referenceGameSourceObjectSchema, A as referenceGameSourceProvenanceSchema, B as referenceGameTeachingSchema, C as referenceGameWorkspaceSchema } from '../schema-9jZzlEWZ.js';
+import 'zod';
 
 type CanonicalReferenceGameJson = null | boolean | number | string | CanonicalReferenceGameJson[] | {
     [key: string]: CanonicalReferenceGameJson;
 };
-declare function computeReferenceGameSourceDigest(payload: ReferenceGameSourceManifestPayload): `sha256:${string}`;
+declare function computeReferenceGameSourceFingerprint(payload: ReferenceGameSourceManifestPayload): `sha256:${string}`;
 declare function canonicalizeReferenceGameSourcePayload(payload: ReferenceGameSourceManifestPayload): CanonicalReferenceGameJson;
+/** Locale-independent UTF-16 code-unit order, equivalent to Java String.compareTo. */
+declare function compareReferenceGameCanonicalStrings(left: string, right: string): number;
 
-export { REFERENCE_GAME_MANIFEST_SCHEMA_VERSION, REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION, type ReferenceGameDemoRelease, type ReferenceGameManifestV3, type ReferenceGameRights, type ReferenceGameSdkPolicy, type ReferenceGameSourceEntry, type ReferenceGameSourceManifest, type ReferenceGameSourceManifestPayload, type ReferenceGameSourceObject, type ReferenceGameSourceProvenance, type ReferenceGameTeaching, type ReferenceGameWorkspace, canonicalizeReferenceGameSourcePayload, computeReferenceGameSourceDigest, isPackageableReferenceGame, parseReferenceGameManifestV3, parseReferenceGameSourceManifest, referenceGameDemoReleaseSchema, referenceGameManifestV3Schema, referenceGameRightsSchema, referenceGameSdkPolicySchema, referenceGameSha256DigestSchema, referenceGameSourceEntrySchema, referenceGameSourceManifestPayloadSchema, referenceGameSourceManifestSchema, referenceGameSourceObjectSchema, referenceGameSourceProvenanceSchema, referenceGameTeachingSchema, referenceGameWorkspaceSchema };
+export { ReferenceGameSourceManifestPayload, canonicalizeReferenceGameSourcePayload, compareReferenceGameCanonicalStrings, computeReferenceGameSourceFingerprint };

package/dist/reference-games/index.js

@@ -1,216 +1,35 @@
+import {
+  REFERENCE_GAME_MANIFEST_SCHEMA_VERSION,
+  REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION,
+  isPackageableReferenceGame,
+  parseReferenceGameManifestV3,
+  parseReferenceGameSourceManifest,
+  referenceGameDemoReleaseSchema,
+  referenceGameManifestV3Schema,
+  referenceGameRightsSchema,
+  referenceGameSdkPolicySchema,
+  referenceGameSha256DigestSchema,
+  referenceGameSourceEntrySchema,
+  referenceGameSourceInventoryPolicySchema,
+  referenceGameSourceManifestPayloadSchema,
+  referenceGameSourceManifestSchema,
+  referenceGameSourceObjectSchema,
+  referenceGameSourceProvenanceSchema,
+  referenceGameTeachingSchema,
+  referenceGameWorkspaceSchema
+} from "../chunk-45P5CEGH.js";
+import {
+  canonicalizeReferenceGameSourcePayload,
+  compareReferenceGameCanonicalStrings,
+  computeReferenceGameSourceFingerprint
+} from "../chunk-UNVCT5Z7.js";
 import "../chunk-PZ5AY32C.js";
-
-// src/reference-games/canonical.ts
-import { sha256 } from "@noble/hashes/sha2.js";
-import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
-function computeReferenceGameSourceDigest(payload) {
-  const canonical = canonicalizeReferenceGameSourcePayload(payload);
-  const encoded = JSON.stringify(canonical);
-  return `sha256:${bytesToHex(sha256(utf8ToBytes(encoded)))}`;
-}
-function canonicalizeReferenceGameSourcePayload(payload) {
-  return canonicalizeJson({
-    ...payload,
-    games: [...payload.games].sort(
-      (left, right) => left.id.localeCompare(right.id)
-    ),
-    objects: [...payload.objects].sort(
-      (left, right) => left.path.localeCompare(right.path)
-    )
-  });
-}
-function canonicalizeJson(value) {
-  if (value === null || typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "string") {
-    return value.normalize("NFC");
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(
-        "reference game source JSON contains a non-finite number"
-      );
-    }
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => canonicalizeJson(item));
-  }
-  if (typeof value === "object") {
-    const entries = Object.entries(value);
-    for (const [, item] of entries) {
-      if (item === void 0) {
-        throw new Error("reference game source JSON contains undefined");
-      }
-    }
-    return Object.fromEntries(
-      entries.map(([key, item]) => [key.normalize("NFC"), item]).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalizeJson(item)])
-    );
-  }
-  throw new Error(
-    `reference game source JSON contains unsupported ${typeof value} value`
-  );
-}
-
-// src/reference-games/schema.ts
-import { z } from "zod";
-var REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION = 2;
-var REFERENCE_GAME_MANIFEST_SCHEMA_VERSION = 3;
-var referenceGameSha256DigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/);
-var referenceGameSourceObjectSchema = z.object({
-  path: z.string().min(1),
-  sha256: referenceGameSha256DigestSchema,
-  byteLength: z.number().int().nonnegative()
-}).strict();
-var referenceGameSourceEntrySchema = z.object({
-  id: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
-  root: z.string().regex(/^examples\/reference-games\/[a-z0-9-]+$/),
-  sourceSha256: referenceGameSha256DigestSchema,
-  packageJsonSha256: referenceGameSha256DigestSchema,
-  lockfileSha256: referenceGameSha256DigestSchema,
-  sdkSpecifier: z.string().min(1),
-  manifest: z.string().min(1),
-  reducer: z.string().min(1),
-  ui: z.string().min(1),
-  behaviorScenarios: z.array(z.string().min(1)).min(1),
-  uiScenarios: z.array(z.string().min(1)).min(1),
-  mechanics: z.array(z.string().min(1)).min(1),
-  readFirst: z.array(z.string().min(1)).min(1)
-}).strict();
-var referenceGameSourceManifestPayloadSchema = z.object({
-  games: z.array(referenceGameSourceEntrySchema).min(1),
-  objects: z.array(referenceGameSourceObjectSchema).min(1)
-}).strict();
-var referenceGameSourceProvenanceSchema = z.discriminatedUnion(
-  "kind",
-  [
-    z.object({ kind: z.literal("worktree") }).strict(),
-    z.object({
-      kind: z.literal("git"),
-      repository: z.literal("dreamboard-games/dreamboard-sdk"),
-      revision: z.string().regex(/^[a-f0-9]{40}$/)
-    }).strict()
-  ]
-);
-var referenceGameSourceManifestSchema = z.object({
-  schemaVersion: z.literal(REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION),
-  manifestType: z.literal("dreamboard.reference-game-source"),
-  bundleDigest: referenceGameSha256DigestSchema,
-  payload: referenceGameSourceManifestPayloadSchema,
-  provenance: referenceGameSourceProvenanceSchema
-}).strict().superRefine((value, context) => {
-  const digest = computeReferenceGameSourceDigest(value.payload);
-  if (value.bundleDigest !== digest) {
-    context.addIssue({
-      code: "custom",
-      path: ["bundleDigest"],
-      message: "bundleDigest must match the canonical payload digest"
-    });
-  }
-});
-var referenceGameIdSchema = z.string().regex(/^[a-z0-9][a-z0-9-]*$/);
-var referenceGameWorkspacePathSchema = z.string().min(1);
-var referenceGameWorkspaceSchema = z.object({
-  manifest: referenceGameWorkspacePathSchema,
-  reducer: referenceGameWorkspacePathSchema,
-  ui: referenceGameWorkspacePathSchema,
-  behaviorScenarios: z.array(referenceGameWorkspacePathSchema).min(1),
-  uiScenarios: z.array(referenceGameWorkspacePathSchema).min(1)
-}).strict();
-var referenceGameTeachingSchema = z.object({
-  whatThisTeaches: z.array(z.string().min(1)).min(1),
-  whenToCopyThisPattern: z.array(z.string().min(1)).min(1),
-  readFirst: z.array(referenceGameWorkspacePathSchema).min(1)
-}).strict();
-var referenceGameDemoScreenshotPresetSchema = z.object({
-  viewport: z.tuple([
-    z.number().int().positive(),
-    z.number().int().positive()
-  ]),
-  theme: z.string().min(1),
-  stagePadding: z.number().int().nonnegative(),
-  frame: z.string().min(1)
-}).strict();
-var referenceGameDemoReleaseSchema = z.object({
-  slug: referenceGameIdSchema,
-  name: z.string().min(1),
-  description: z.string().min(1),
-  overview: z.string().min(1),
-  creator: z.string().min(1),
-  minPlayers: z.number().int().positive(),
-  maxPlayers: z.number().int().positive(),
-  playTimeMinMinutes: z.number().int().positive(),
-  playTimeMaxMinutes: z.number().int().positive(),
-  difficulty: z.number().int().min(1).max(5),
-  mechanics: z.array(z.string().min(1)).min(1),
-  categories: z.array(z.string().min(1)).min(1),
-  heroImageUrl: z.string().min(1),
-  estimatedMinutes: z.number().int().positive(),
-  demoPlayerCount: z.number().int().positive(),
-  screenshot: z.object({
-    presets: z.record(z.string().min(1), referenceGameDemoScreenshotPresetSchema).refine((value) => Object.keys(value).length > 0, {
-      message: "screenshot.presets must include at least one preset"
-    })
-  }).strict()
-}).strict().superRefine((value, context) => {
-  if (value.maxPlayers < value.minPlayers) {
-    context.addIssue({
-      code: "custom",
-      path: ["maxPlayers"],
-      message: "maxPlayers must be greater than or equal to minPlayers"
-    });
-  }
-  if (value.playTimeMaxMinutes < value.playTimeMinMinutes) {
-    context.addIssue({
-      code: "custom",
-      path: ["playTimeMaxMinutes"],
-      message: "playTimeMaxMinutes must be greater than or equal to playTimeMinMinutes"
-    });
-  }
-});
-var referenceGameRightsSchema = z.object({
-  mechanicsProvenance: z.string().min(1),
-  sourceCode: z.string().min(1),
-  codeLicense: z.string().min(1),
-  ruleText: z.string().min(1),
-  artwork: z.string().min(1),
-  assetLicenseManifest: z.string().min(1),
-  thirdPartyMarks: z.array(z.string()),
-  reviewStatus: z.literal("approved"),
-  reviewedBy: z.string().min(1),
-  reviewedAt: z.string().min(1)
-}).strict();
-var referenceGameSdkPolicySchema = z.object({
-  dependency: z.literal("@dreamboard-games/sdk"),
-  versionPolicy: z.literal("exact")
-}).strict();
-var referenceGameManifestV3Schema = z.object({
-  schemaVersion: z.literal(REFERENCE_GAME_MANIFEST_SCHEMA_VERSION),
-  id: referenceGameIdSchema,
-  displayName: z.string().min(1),
-  workspace: referenceGameWorkspaceSchema,
-  teaching: referenceGameTeachingSchema,
-  demoRelease: referenceGameDemoReleaseSchema.optional(),
-  mechanics: z.array(z.string().min(1)).min(1),
-  uiPatterns: z.array(z.string().min(1)).min(1),
-  rights: referenceGameRightsSchema,
-  sdk: referenceGameSdkPolicySchema
-}).strict();
-function parseReferenceGameSourceManifest(value) {
-  return referenceGameSourceManifestSchema.parse(value);
-}
-function parseReferenceGameManifestV3(value) {
-  return referenceGameManifestV3Schema.parse(value);
-}
-function isPackageableReferenceGame(game) {
-  return game.demoRelease !== void 0;
-}
 export {
   REFERENCE_GAME_MANIFEST_SCHEMA_VERSION,
   REFERENCE_GAME_SOURCE_MANIFEST_SCHEMA_VERSION,
   canonicalizeReferenceGameSourcePayload,
-  computeReferenceGameSourceDigest,
+  compareReferenceGameCanonicalStrings,
+  computeReferenceGameSourceFingerprint,
   isPackageableReferenceGame,
   parseReferenceGameManifestV3,
   parseReferenceGameSourceManifest,
@@ -220,6 +39,7 @@ export {
   referenceGameSdkPolicySchema,
   referenceGameSha256DigestSchema,
   referenceGameSourceEntrySchema,
+  referenceGameSourceInventoryPolicySchema,
   referenceGameSourceManifestPayloadSchema,
   referenceGameSourceManifestSchema,
   referenceGameSourceObjectSchema,