@dreamboard-games/sdk 0.4.0-alpha.1 → 0.4.0-alpha.3

package/dist/{ResourceCounter-BTXklCEZ.d.ts → ResourceCounter-BuiNstXs.d.ts}

@@ -28,6 +28,10 @@ declare function useRegisterMobileHand(hand: MobileHandRegistration): void;
  * the breakpoint with a CSS media query. Returns `false` outside `<UI.Root>`.
  */
 declare function useMobileHandTrayActive(): boolean;
+declare function useOverlayInsets(): {
+    bottom: number;
+};
+declare function useRegisterBottomOverlayInset(id: string, height: number): void;
 
 type ResourceId = string;
 interface ResourceDisplayConfig<Resource extends string = ResourceId> {
@@ -99,4 +103,4 @@ declare const ResourceCounter: {
     Label: typeof ResourceCounterLabel;
 };
 
-export { type BoundResourceCounterRootProps as B, type HandRole as H, type MobileHandRegistration as M, ResourceCounter as R, MobileHandTrayProvider as a, type ResourceCounterComponents as b, ResourceCounterCount as c, ResourceCounterIcon as d, ResourceCounterItem as e, type ResourceCounterItemState as f, ResourceCounterLabel as g, type ResourceCounterPartProps as h, type ResourceCounterProps as i, ResourceCounterRoot as j, type ResourceCounterRootProps as k, type ResourceDisplayConfig as l, type ResourceIconProps as m, createResourceCounter as n, useRegisterMobileHand as o, useMobileHandTrayActive as u };
+export { type BoundResourceCounterRootProps as B, type HandRole as H, type MobileHandRegistration as M, ResourceCounter as R, MobileHandTrayProvider as a, type ResourceCounterComponents as b, ResourceCounterCount as c, ResourceCounterIcon as d, ResourceCounterItem as e, type ResourceCounterItemState as f, ResourceCounterLabel as g, type ResourceCounterPartProps as h, type ResourceCounterProps as i, ResourceCounterRoot as j, type ResourceCounterRootProps as k, type ResourceDisplayConfig as l, type ResourceIconProps as m, createResourceCounter as n, useOverlayInsets as o, useRegisterBottomOverlayInset as p, useRegisterMobileHand as q, useMobileHandTrayActive as u };

package/dist/{ThemeProvider-DvMl17Ny.d.ts → ThemeProvider-B1sIoBlX.d.ts}

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { CSSProperties, ReactNode } from 'react';
-import { $ as Theme, a1 as ThemeOverride } from './hex-board-view-UCUjMALd.js';
+import { $ as Theme, a1 as ThemeOverride } from './hex-board-view-Kz9Q_zsv.js';
 
 /**
  * The set of preset theme ids ships in `@dreamboard-games/sdk/ui`. Authors

package/dist/{attributes-BrZtP9az.d.ts → attributes-DbvyMbXw.d.ts}

@@ -1,4 +1,4 @@
-import { q as BrowserInteractionIntent, i as BrowserInteractionCandidateState, h as BrowserInteractionActuatorKind, G as BrowserInteractionSurfaceEffect, k as BrowserInteractionEffectPattern, s as BrowserInteractionPreparationTarget, v as BrowserInteractionReadiness, R as GameplayBrowserInteractionIntent, T as GameplaySemanticEffect, U as GameplaySemanticEffectPattern } from './types-BqzHkNMA.js';
+import { q as BrowserInteractionIntent, i as BrowserInteractionCandidateState, h as BrowserInteractionActuatorKind, K as BrowserInteractionSurfaceEffect, k as BrowserInteractionEffectPattern, w as BrowserInteractionPreparationTarget, z as BrowserInteractionReadiness, V as GameplayBrowserInteractionIntent, X as GameplaySemanticEffect, Y as GameplaySemanticEffectPattern } from './types-DJj5MJkl.js';
 
 type BrowserInteractionAttributeMap = Record<string, string | boolean>;
 interface BrowserInteractionRootAttributesInput {
@@ -29,8 +29,19 @@ interface BrowserInteractionActuatorAttributesInput {
     readonly preparationPatterns?: readonly BrowserInteractionEffectPattern[];
     readonly prepares?: BrowserInteractionPreparationTarget;
 }
+interface BrowserInteractionPointerTargetAttributesInput {
+    readonly surface: string;
+    readonly scopeId: string;
+    readonly interactionKey: string;
+    readonly interactionId: string;
+    readonly descriptorDigest?: string;
+    readonly targetId: string;
+    readonly enabled?: boolean;
+    readonly acceptedEffectPatterns: readonly BrowserInteractionEffectPattern[];
+}
 declare function createBrowserInteractionRootAttributes(input: BrowserInteractionRootAttributesInput): BrowserInteractionAttributeMap;
 declare function createBrowserInteractionActuatorAttributes(input: BrowserInteractionActuatorAttributesInput): BrowserInteractionAttributeMap;
+declare function createBrowserInteractionPointerTargetAttributes(input: BrowserInteractionPointerTargetAttributesInput): BrowserInteractionAttributeMap;
 type GameplayInteractionRootAttributesInput = Omit<BrowserInteractionRootAttributesInput, "surface">;
 type GameplayActuatorAttributesInput = Omit<BrowserInteractionActuatorAttributesInput, "surface" | "intent" | "semanticEffects" | "acceptedEffectPatterns" | "preparationPatterns"> & {
     readonly intent: GameplayBrowserInteractionIntent;
@@ -38,8 +49,12 @@ type GameplayActuatorAttributesInput = Omit<BrowserInteractionActuatorAttributes
     readonly acceptedEffectPatterns?: readonly GameplaySemanticEffectPattern[];
     readonly preparationPatterns?: readonly GameplaySemanticEffectPattern[];
 };
+type GameplayPointerTargetAttributesInput = Omit<BrowserInteractionPointerTargetAttributesInput, "surface" | "acceptedEffectPatterns"> & {
+    readonly acceptedEffectPatterns: readonly GameplaySemanticEffectPattern[];
+};
 declare function createGameplayInteractionRootAttributes(input: GameplayInteractionRootAttributesInput): BrowserInteractionAttributeMap;
 declare function createGameplayActuatorAttributes(input: GameplayActuatorAttributesInput): BrowserInteractionAttributeMap;
+declare function createGameplayPointerTargetAttributes(input: GameplayPointerTargetAttributesInput): BrowserInteractionAttributeMap;
 declare function createBrowserInteractionActuatorKey(input: {
     readonly surface: string;
     readonly scopeId: string;
@@ -50,4 +65,4 @@ declare function createBrowserInteractionActuatorKey(input: {
     readonly actuatorKind: BrowserInteractionActuatorKind;
 }): string;
 
-export { type BrowserInteractionActuatorAttributesInput as B, type GameplayActuatorAttributesInput as G, type BrowserInteractionAttributeMap as a, type BrowserInteractionRootAttributesInput as b, type GameplayInteractionRootAttributesInput as c, createBrowserInteractionActuatorAttributes as d, createBrowserInteractionActuatorKey as e, createBrowserInteractionRootAttributes as f, createGameplayActuatorAttributes as g, createGameplayInteractionRootAttributes as h };
+export { type BrowserInteractionActuatorAttributesInput as B, type GameplayActuatorAttributesInput as G, type BrowserInteractionAttributeMap as a, type BrowserInteractionPointerTargetAttributesInput as b, type BrowserInteractionRootAttributesInput as c, type GameplayInteractionRootAttributesInput as d, type GameplayPointerTargetAttributesInput as e, createBrowserInteractionActuatorAttributes as f, createBrowserInteractionActuatorKey as g, createBrowserInteractionPointerTargetAttributes as h, createBrowserInteractionRootAttributes as i, createGameplayActuatorAttributes as j, createGameplayInteractionRootAttributes as k, createGameplayPointerTargetAttributes as l };

package/dist/authoring/index.d.ts

@@ -0,0 +1,66 @@
+import { JsonValue, GameTopologyManifest } from '../types.js';
+
+type GeneratedAuthoringMetadataV1 = {
+    sdkVersion: string;
+    codegenVersion: string;
+    manifestSchemaVersion: number;
+    generatedArtifactSchemaVersion: number;
+};
+type AuthoringValidationResultV1 = {
+    valid: boolean;
+    errors: readonly string[];
+    warnings: readonly string[];
+};
+type GeneratedArtifactV1 = {
+    path: string;
+    ownership: "authoritative" | "seed" | "derived-test";
+    content: string;
+    contentSha256: string;
+};
+type GeneratedPathPatternV1 = {
+    prefix: string;
+    suffix: string;
+};
+type GenerateTestArtifactsInputV1 = {
+    manifest: GameTopologyManifest;
+};
+type AuthoringManifestConformanceCaseV1 = {
+    id: string;
+    manifest: JsonValue;
+    expected: {
+        valid: true;
+        transportValid: true;
+        materializedSha256: string;
+    } | {
+        valid: false;
+        transportValid: boolean;
+        diagnosticCodes: readonly string[];
+    };
+};
+type ProjectAuthoringAdapterV1 = {
+    protocolVersion: 1;
+    metadata: GeneratedAuthoringMetadataV1;
+    generatedPaths: readonly string[];
+    generatedPathPatterns: readonly GeneratedPathPatternV1[];
+    manifestConformanceCases: readonly AuthoringManifestConformanceCaseV1[];
+    validateManifest(manifest: unknown): AuthoringValidationResultV1;
+    materializeManifest(manifest: unknown): JsonValue;
+    generateWorkspaceArtifacts(manifest: unknown): readonly GeneratedArtifactV1[];
+    generateTestArtifacts(input: GenerateTestArtifactsInputV1): readonly GeneratedArtifactV1[];
+};
+
+declare function diagnosticCodesForValidationErrors(errors: readonly string[]): readonly string[];
+
+declare function validateManifest(manifest: unknown): AuthoringValidationResultV1;
+declare function materializeManifest(manifest: unknown): JsonValue;
+declare function generateWorkspaceArtifacts(manifest: unknown): readonly GeneratedArtifactV1[];
+declare function generateTestArtifacts(input: GenerateTestArtifactsInputV1): readonly GeneratedArtifactV1[];
+declare const GENERATED_WORKSPACE_PATHS: readonly [...string[], "test/generated/base-state.json"];
+declare const GENERATED_WORKSPACE_PATH_PATTERNS: {
+    prefix: string;
+    suffix: string;
+}[];
+declare const MANIFEST_CONFORMANCE_CASES: readonly AuthoringManifestConformanceCaseV1[];
+declare const projectAuthoringAdapter: ProjectAuthoringAdapterV1;
+
+export { type AuthoringManifestConformanceCaseV1, type AuthoringValidationResultV1, GENERATED_WORKSPACE_PATHS, GENERATED_WORKSPACE_PATH_PATTERNS, type GenerateTestArtifactsInputV1, type GeneratedArtifactV1, type GeneratedAuthoringMetadataV1, type GeneratedPathPatternV1, MANIFEST_CONFORMANCE_CASES, type ProjectAuthoringAdapterV1, diagnosticCodesForValidationErrors, generateTestArtifacts, generateWorkspaceArtifacts, materializeManifest, projectAuthoringAdapter, validateManifest };

package/dist/authoring/index.js

@@ -0,0 +1,560 @@
+import {
+  GENERATED_AUTHORING_METADATA
+} from "../chunk-DQ7GCD6C.js";
+import {
+  AUTHORITATIVE_GENERATED_FILES,
+  SEED_FILES,
+  SEED_FILE_PATTERNS,
+  generateAuthoritativeFiles,
+  generateSeedFiles,
+  materializeManifestTable,
+  validateManifestAuthoring
+} from "../chunk-CP35NPPY.js";
+import "../chunk-PZ5AY32C.js";
+
+// src/authoring/adapter.ts
+import { createHash } from "crypto";
+
+// src/authoring/manifest-conformance-cases.ts
+function baseManifest(cardSet, overrides = {}) {
+  return {
+    players: {
+      minPlayers: 2,
+      maxPlayers: 2,
+      optimalPlayers: 2
+    },
+    cardSets: [cardSet],
+    zones: [],
+    boardTemplates: [],
+    boards: [],
+    pieceTypes: [],
+    pieceSeeds: [],
+    dieTypes: [],
+    dieSeeds: [],
+    resources: [],
+    setupOptions: [],
+    setupProfiles: [],
+    ...overrides
+  };
+}
+function manualCardSet(id, defaultHome, cards) {
+  const cardSet = {
+    id,
+    name: id,
+    type: "manual",
+    cardSchema: { properties: {} },
+    defaultHome,
+    cards
+  };
+  return cardSet;
+}
+var sharedZone = {
+  id: "shared-zone",
+  name: "Shared Zone",
+  scope: "shared",
+  allowedCardSetIds: ["cards"]
+};
+var sharedBoard = {
+  id: "square-board",
+  name: "Square Board",
+  layout: "square",
+  scope: "shared",
+  spaces: [
+    { id: "a1", row: 0, col: 0 },
+    { id: "a2", row: 0, col: 1 },
+    { id: "b1", row: 1, col: 0 },
+    { id: "b2", row: 1, col: 1 }
+  ],
+  relations: [],
+  containers: [
+    {
+      id: "display-row",
+      name: "Display Row",
+      host: { type: "board" }
+    }
+  ],
+  edges: [],
+  vertices: []
+};
+var sharedTopology = {
+  boards: [sharedBoard],
+  pieceTypes: [
+    {
+      id: "holder",
+      name: "Holder",
+      slots: [{ id: "pocket" }]
+    }
+  ],
+  pieceSeeds: [{ id: "holder-a", typeId: "holder" }]
+};
+var fixtures = [
+  {
+    id: "manual-default-detached",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "detached" }, [
+        { type: "marker", name: "Marker", count: 1, properties: {} }
+      ])
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "ed6f7ce2ff4fbe697e49134f1d59157cf146e202db29a77be50e8326585f535c"
+    }
+  },
+  {
+    id: "manual-default-shared-zone",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "zone", zoneId: "shared-zone" }, [
+        { type: "coin", name: "Coin", count: 2, properties: {} }
+      ]),
+      { zones: [sharedZone] }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "75028d28dbc415c81db5e2d780d55b04c4db36378a149bc02b0194d94a8cc2b9"
+    }
+  },
+  {
+    id: "preset-default-shared-zone",
+    manifest: baseManifest(
+      {
+        id: "cards",
+        name: "Preset Cards",
+        type: "preset",
+        presetId: "standard_52_deck",
+        defaultHome: { type: "zone", zoneId: "shared-zone" }
+      },
+      { zones: [sharedZone] }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "b3471c577ed266667b16799f75aa9b7358100a94108aa46a31ad16a0291f67ca"
+    }
+  },
+  {
+    id: "manual-per-card-detached-override",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "zone", zoneId: "shared-zone" }, [
+        {
+          type: "removed",
+          name: "Removed",
+          count: 1,
+          home: { type: "detached" },
+          properties: {}
+        }
+      ]),
+      { zones: [sharedZone] }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "fdcb2de78fc391e11aca1f266fd8bbb348a82faa0fbbac1d8eb1defd8697a0e9"
+    }
+  },
+  {
+    id: "manual-per-card-shared-zone-override",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "detached" }, [
+        {
+          type: "dealt",
+          name: "Dealt",
+          count: 1,
+          home: { type: "zone", zoneId: "shared-zone" },
+          properties: {}
+        }
+      ]),
+      { zones: [sharedZone] }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "b6bee1db85f16e8a12a7136c7d524591f925427c8ec04d64b07905c5bc859d7a"
+    }
+  },
+  {
+    id: "manual-compatible-zones-no-inference",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "detached" }, [
+        { type: "token", name: "Token", count: 1, properties: {} }
+      ]),
+      {
+        zones: [
+          sharedZone,
+          {
+            ...sharedZone,
+            id: "second-compatible-zone",
+            name: "Second Compatible Zone"
+          }
+        ]
+      }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "2727728ba3743d2b1874b2bc573b48c88f962fdcbdcdf20c62bed551d6d955c4"
+    }
+  },
+  {
+    id: "manual-per-player-zone-rejected",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "zone", zoneId: "hand" }, [
+        { type: "secret", name: "Secret", count: 1, properties: {} }
+      ]),
+      {
+        zones: [
+          {
+            id: "hand",
+            name: "Hand",
+            scope: "perPlayer",
+            allowedCardSetIds: ["cards"]
+          }
+        ]
+      }
+    ),
+    expected: {
+      valid: false,
+      transportValid: true,
+      diagnosticCodes: ["CARD_HOME_PER_PLAYER_ZONE_REJECTED"]
+    }
+  },
+  {
+    id: "manual-space-home",
+    manifest: baseManifest(
+      manualCardSet(
+        "cards",
+        { type: "space", boardId: "square-board", spaceId: "a1" },
+        [{ type: "space-card", name: "Space", count: 1, properties: {} }]
+      ),
+      sharedTopology
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "429abfb3276c67cdca59d3dc077fc73022a9716bccef2c43f6805ff5cce0f2c2"
+    }
+  },
+  {
+    id: "manual-container-home",
+    manifest: baseManifest(
+      manualCardSet(
+        "cards",
+        {
+          type: "container",
+          boardId: "square-board",
+          containerId: "display-row"
+        },
+        [
+          {
+            type: "container-card",
+            name: "Container",
+            count: 1,
+            properties: {}
+          }
+        ]
+      ),
+      sharedTopology
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "eff372263227b316d064a519cf282a6cc1d2d8df4ac04673b7f47ac518d7a2a3"
+    }
+  },
+  {
+    id: "manual-slot-home",
+    manifest: baseManifest(
+      manualCardSet(
+        "cards",
+        {
+          type: "slot",
+          host: { kind: "piece", id: "holder-a" },
+          slotId: "pocket"
+        },
+        [{ type: "slot-card", name: "Slot", count: 1, properties: {} }]
+      ),
+      sharedTopology
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "af3111f8d861ae69b77f2f46ba3df9f2f698f3306c412efc91095544e8121ab6"
+    }
+  },
+  {
+    id: "manual-edge-home",
+    manifest: baseManifest(
+      manualCardSet(
+        "cards",
+        {
+          type: "edge",
+          boardId: "square-board",
+          ref: { spaces: ["a1", "a2"] }
+        },
+        [{ type: "edge-card", name: "Edge", count: 1, properties: {} }]
+      ),
+      sharedTopology
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "f8606ea25f52d9bf801aa4fee9f558b60d7f39bcd601d57bdfccdf1ddbf4c500"
+    }
+  },
+  {
+    id: "manual-vertex-home",
+    manifest: baseManifest(
+      manualCardSet(
+        "cards",
+        {
+          type: "vertex",
+          boardId: "square-board",
+          ref: { spaces: ["a1", "a2", "b1", "b2"] }
+        },
+        [{ type: "vertex-card", name: "Vertex", count: 1, properties: {} }]
+      ),
+      sharedTopology
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "e84a4920ea8b71052acd42accf11101380ab982e493ebe207113dd4d243034de"
+    }
+  },
+  {
+    id: "manual-invalid-target-id",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "zone", zoneId: "missing-zone" }, [
+        { type: "lost", name: "Lost", count: 1, properties: {} }
+      ])
+    ),
+    expected: {
+      valid: false,
+      transportValid: true,
+      diagnosticCodes: ["AUTHORING_VALIDATION_ERROR"]
+    }
+  },
+  {
+    id: "manual-count-order",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "zone", zoneId: "shared-zone" }, [
+        { type: "first", name: "First", count: 3, properties: {} },
+        { type: "second", name: "Second", count: 2, properties: {} }
+      ]),
+      { zones: [sharedZone] }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "2e4ced71909d4c36053317311c9ceaf3bf3adba875bff3fe9596bbea47746423"
+    }
+  },
+  {
+    id: "manual-generated-scenario-base",
+    manifest: baseManifest(
+      manualCardSet("cards", { type: "zone", zoneId: "shared-zone" }, [
+        { type: "alpha", name: "Alpha", count: 2, properties: {} },
+        { type: "beta", name: "Beta", count: 1, properties: {} }
+      ]),
+      { zones: [sharedZone] }
+    ),
+    expected: {
+      valid: true,
+      transportValid: true,
+      materializedSha256: "b1b65d708b503036a49434c64c6f4aab3bedd295681bd103b69c4b98fdd5e2bb"
+    }
+  },
+  {
+    id: "manual-default-required",
+    manifest: {
+      ...baseManifest(
+        manualCardSet("cards", { type: "detached" }, [
+          { type: "card", name: "Card", count: 1, properties: {} }
+        ])
+      ),
+      cardSets: [
+        {
+          id: "cards",
+          name: "Cards",
+          type: "manual",
+          cardSchema: { properties: {} },
+          cards: [{ type: "card", name: "Card", count: 1, properties: {} }]
+        }
+      ]
+    },
+    expected: {
+      valid: false,
+      transportValid: false,
+      diagnosticCodes: ["MANUAL_CARD_SET_DEFAULT_HOME_REQUIRED"]
+    }
+  }
+];
+function deepFreeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const entry of Object.values(value)) {
+      deepFreeze(entry);
+    }
+    Object.freeze(value);
+  }
+  return value;
+}
+function diagnosticCodesForValidationErrors(errors) {
+  return [...new Set(errors.map(diagnosticCodeForValidationError))].sort();
+}
+function diagnosticCodeForValidationError(error) {
+  if (error.includes(".defaultHome: Manual card sets must declare defaultHome")) {
+    return "MANUAL_CARD_SET_DEFAULT_HOME_REQUIRED";
+  }
+  if (error.includes("cannot target per-player zone")) {
+    return "CARD_HOME_PER_PLAYER_ZONE_REJECTED";
+  }
+  if (error.includes("cannot target per-player board")) {
+    return "CARD_HOME_PER_PLAYER_BOARD_REJECTED";
+  }
+  return "AUTHORING_VALIDATION_ERROR";
+}
+function createManifestConformanceCases() {
+  return deepFreeze(
+    fixtures
+  );
+}
+
+// src/authoring/adapter.ts
+var PLAYER_IDS = ["player-1", "player-2"];
+function stableJson(value) {
+  if (value === void 0) {
+    return "null";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  }
+  return `{${Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function assertManifest(manifest) {
+  if (!manifest || typeof manifest !== "object") {
+    throw new Error("Expected a manifest object.");
+  }
+  return manifest;
+}
+function normalizeArtifact(path, content, ownership) {
+  if (path.length === 0 || path.startsWith("/") || path.includes("\\") || path.split("/").some((segment) => !segment || segment === "." || segment === "..")) {
+    throw new Error(`Generated artifact path '${path}' is not normalized.`);
+  }
+  return {
+    path,
+    ownership,
+    content,
+    contentSha256: sha256(content)
+  };
+}
+function normalizeArtifacts(entries, ownership) {
+  return Object.entries(entries).map(([path, content]) => normalizeArtifact(path, content, ownership)).sort((left, right) => left.path.localeCompare(right.path));
+}
+function validateNoDuplicateArtifactPaths(artifacts) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const artifact of artifacts) {
+    if (seen.has(artifact.path)) {
+      throw new Error(
+        `Generated artifact path '${artifact.path}' was emitted twice.`
+      );
+    }
+    seen.add(artifact.path);
+    if (artifact.contentSha256 !== sha256(artifact.content)) {
+      throw new Error(
+        `Generated artifact '${artifact.path}' has a stale hash.`
+      );
+    }
+  }
+}
+function validateManifest(manifest) {
+  try {
+    const gameManifest = assertManifest(manifest);
+    const result = validateManifestAuthoring(gameManifest);
+    const errors = [...result.errors];
+    if (errors.length === 0) {
+      try {
+        materializeManifest(gameManifest);
+      } catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings: result.warnings
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [error instanceof Error ? error.message : String(error)],
+      warnings: []
+    };
+  }
+}
+function materializeManifest(manifest) {
+  return materializeManifestTable({
+    manifest: assertManifest(manifest),
+    playerIds: PLAYER_IDS,
+    shuffleItems: (values) => [...values]
+  });
+}
+function generateWorkspaceArtifacts(manifest) {
+  const gameManifest = assertManifest(manifest);
+  const artifacts = [
+    ...normalizeArtifacts(
+      generateAuthoritativeFiles(gameManifest),
+      "authoritative"
+    ),
+    ...normalizeArtifacts(generateSeedFiles(gameManifest), "seed")
+  ].sort((left, right) => left.path.localeCompare(right.path));
+  validateNoDuplicateArtifactPaths(artifacts);
+  return artifacts;
+}
+function generateTestArtifacts(input) {
+  const materialized = materializeManifest(input.manifest);
+  return [
+    normalizeArtifact(
+      "test/generated/base-state.json",
+      `${stableJson(materialized)}
+`,
+      "derived-test"
+    )
+  ];
+}
+var GENERATED_WORKSPACE_PATHS = [
+  ...AUTHORITATIVE_GENERATED_FILES,
+  ...SEED_FILES,
+  "test/generated/base-state.json"
+];
+var GENERATED_WORKSPACE_PATH_PATTERNS = SEED_FILE_PATTERNS;
+var MANIFEST_CONFORMANCE_CASES = createManifestConformanceCases();
+var projectAuthoringAdapter = {
+  protocolVersion: 1,
+  metadata: GENERATED_AUTHORING_METADATA,
+  generatedPaths: GENERATED_WORKSPACE_PATHS,
+  generatedPathPatterns: GENERATED_WORKSPACE_PATH_PATTERNS,
+  manifestConformanceCases: MANIFEST_CONFORMANCE_CASES,
+  validateManifest,
+  materializeManifest,
+  generateWorkspaceArtifacts,
+  generateTestArtifacts
+};
+export {
+  GENERATED_WORKSPACE_PATHS,
+  GENERATED_WORKSPACE_PATH_PATTERNS,
+  MANIFEST_CONFORMANCE_CASES,
+  diagnosticCodesForValidationErrors,
+  generateTestArtifacts,
+  generateWorkspaceArtifacts,
+  materializeManifest,
+  projectAuthoringAdapter,
+  validateManifest
+};
+//# sourceMappingURL=index.js.map