@dreamboard-games/sdk 0.4.0-alpha.8 → 0.5.0-alpha.0

package/README.md

@@ -1,19 +1,57 @@
 # @dreamboard-games/sdk
 
-The public Dreamboard SDK package. This repository publishes one consumer
-package, `@dreamboard-games/sdk`; public capabilities are exposed through the
-package export map rather than separate installable workspace packages.
+The public TypeScript SDK for authoring, testing, and rendering Dreamboard
+games. Install this package rather than any of the repository's unpublished
+workspace inputs.
 
-Internal workspaces such as `sdk-types`, `workspace-codegen`, and
-`reducer-contract` are implementation inputs. Consumers should not install or
-import those package names directly.
+```sh
+pnpm add @dreamboard-games/sdk
+```
 
-Typical imports:
+The package's declarations and export map are the API authority. Supported
+imports include the root module and explicit subpaths for authoring, runtime,
+reducer contracts, testing, browser interaction, UI, and reference-game
+metadata. Import only subpaths present in the installed package's `exports`
+field.
 
 ```ts
-import {
-  DREAMBOARD_SDK_PACKAGE_SET,
-  DREAMBOARD_SDK_VERSION,
-} from "@dreamboard-games/sdk";
+import { DREAMBOARD_SDK_VERSION } from "@dreamboard-games/sdk";
 import type { ReducerWire } from "@dreamboard-games/sdk/reducer-contract";
+import {
+  REFERENCE_GAME_MANIFEST_SCHEMA_VERSION,
+  parseReferenceGameManifest,
+  type ReferenceGameManifest,
+} from "@dreamboard-games/sdk/reference-games";
+
+const manifest: ReferenceGameManifest = parseReferenceGameManifest(input);
+console.log(REFERENCE_GAME_MANIFEST_SCHEMA_VERSION, manifest.id);
 ```
+
+Reference-game manifests use schema V5. They describe the game workspace,
+teaching purpose, mechanics, UI patterns, and substantive rights metadata.
+
+Include the packaged stylesheet when using SDK UI components:
+
+```ts
+import "@dreamboard-games/sdk/ui/plugin-styles.css";
+```
+
+## Reducer runner contract
+
+`createReducerBundle(game)` returns exactly the contract version and four
+operations: `boardStatic()`, `initialize(input)`, `dispatch({ state, input })`,
+and `project({ state, playerIds })`. The runner contract is `0.5.0`; hosts must
+require that exact version. Dispatch includes validation and effect execution. Initialization returns
+`{ state, terminal?, events? }`, preserving outcomes and events from initial
+phase entry and automatic continuations.
+
+The authoritative state is explicit on every dispatch and projection. A host
+may retain a warm worker and SDK caches, but replaying the same state and input
+must produce the same gameplay result as a fresh worker. Projection timing is
+diagnostic and is excluded from this equivalence.
+
+Seat projections are independent of session versions. The gameplay service
+owns the monotonically increasing version, perspective, and action-set identity.
+The plugin frame basis contains `version`, `actionSetVersion`, and
+`perspectivePlayerId`; it has no generation counter. Hosts merge the separately
+cached board static projection when materializing plugin gameplay frames.

package/dist/authoring/index.d.ts

@@ -1,10 +1,7 @@
-import { JsonValue, GameTopologyManifest } from '../types.js';
+import { JsonValue } from '../types.js';
 
-type GeneratedAuthoringMetadataV1 = {
+type AuthoringMetadataV1 = {
     sdkVersion: string;
-    codegenVersion: string;
-    manifestSchemaVersion: number;
-    generatedArtifactSchemaVersion: number;
 };
 type AuthoringValidationResultV1 = {
     valid: boolean;
@@ -13,7 +10,7 @@ type AuthoringValidationResultV1 = {
 };
 type GeneratedArtifactV1 = {
     path: string;
-    ownership: "authoritative" | "seed" | "derived-test";
+    ownership: "authoritative" | "seed";
     content: string;
     contentSha256: string;
 };
@@ -21,9 +18,6 @@ type GeneratedPathPatternV1 = {
     prefix: string;
     suffix: string;
 };
-type GenerateTestArtifactsInputV1 = {
-    manifest: GameTopologyManifest;
-};
 type AuthoringManifestConformanceCaseV1 = {
     id: string;
     manifest: JsonValue;
@@ -39,14 +33,13 @@ type AuthoringManifestConformanceCaseV1 = {
 };
 type ProjectAuthoringAdapterV1 = {
     protocolVersion: 1;
-    metadata: GeneratedAuthoringMetadataV1;
+    metadata: AuthoringMetadataV1;
     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[];
@@ -54,8 +47,7 @@ declare function diagnosticCodesForValidationErrors(errors: 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_PATHS: readonly string[];
 type GeneratedWorkspacePathPattern = {
     readonly prefix: string;
     readonly suffix: string;
@@ -64,4 +56,4 @@ declare const GENERATED_WORKSPACE_PATH_PATTERNS: readonly GeneratedWorkspacePath
 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 };
+export { type AuthoringManifestConformanceCaseV1, type AuthoringMetadataV1, type AuthoringValidationResultV1, GENERATED_WORKSPACE_PATHS, GENERATED_WORKSPACE_PATH_PATTERNS, type GeneratedArtifactV1, type GeneratedPathPatternV1, MANIFEST_CONFORMANCE_CASES, type ProjectAuthoringAdapterV1, diagnosticCodesForValidationErrors, generateWorkspaceArtifacts, materializeManifest, projectAuthoringAdapter, validateManifest };

package/dist/authoring/index.js

@@ -1,557 +1,21 @@
 import {
-  AUTHORITATIVE_GENERATED_FILES,
-  SEED_FILES,
-  SEED_FILE_PATTERNS,
-  generateAuthoritativeFiles,
-  generateSeedFiles,
-  materializeManifestTable,
-  validateManifestAuthoring
-} from "../chunk-2TAKLJJD.js";
-import {
-  GENERATED_AUTHORING_METADATA
-} from "../chunk-VTNEWMWJ.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,
+  GENERATED_WORKSPACE_PATHS,
+  GENERATED_WORKSPACE_PATH_PATTERNS,
+  MANIFEST_CONFORMANCE_CASES,
+  diagnosticCodesForValidationErrors,
   generateWorkspaceArtifacts,
-  generateTestArtifacts
-};
+  materializeManifest,
+  projectAuthoringAdapter,
+  validateManifest
+} from "../chunk-KGV2EUNN.js";
+import "../chunk-KWHOFBDM.js";
+import "../chunk-HIH6Y4FA.js";
+import "../chunk-PZ5AY32C.js";
 export {
   GENERATED_WORKSPACE_PATHS,
   GENERATED_WORKSPACE_PATH_PATTERNS,
   MANIFEST_CONFORMANCE_CASES,
   diagnosticCodesForValidationErrors,
-  generateTestArtifacts,
   generateWorkspaceArtifacts,
   materializeManifest,
   projectAuthoringAdapter,