@dreamboard-games/workspace-codegen 0.1.0

package/dist/manifest-validation.d.ts

@@ -0,0 +1,6 @@
+import type { GameTopologyManifest } from "@dreamboard/sdk-types";
+export type ManifestAuthoringValidationResult = {
+    errors: string[];
+    warnings: string[];
+};
+export declare function validateManifestAuthoring(manifest: GameTopologyManifest): ManifestAuthoringValidationResult;

package/dist/manifest-validation.js

@@ -0,0 +1,506 @@
+import { resolveHexVertexGeometryKey } from "./hex-geometry.js";
+function isHexBoardTemplateSpec(boardTemplate) {
+    return boardTemplate.layout === "hex";
+}
+function isHexBoardSpec(board) {
+    return board.layout === "hex";
+}
+function collectDuplicateIdIssues(options) {
+    const issues = [];
+    const pathsById = new Map();
+    for (const entry of options.entries) {
+        const id = entry.id?.trim();
+        if (!id) {
+            continue;
+        }
+        const paths = pathsById.get(id) ?? [];
+        paths.push(entry.path);
+        pathsById.set(id, paths);
+    }
+    for (const [id, paths] of pathsById.entries()) {
+        if (paths.length > 1) {
+            issues.push(`${paths.join(", ")}: Duplicate ${options.label} '${id}'.`);
+        }
+    }
+    return issues;
+}
+function renderCardInstanceIds(card) {
+    return card.count > 1
+        ? Array.from({ length: card.count }, (_, index) => `${card.type}-${index + 1}`)
+        : [card.type];
+}
+function expandSeedIds(seeds) {
+    return seeds.flatMap((seed) => {
+        const count = seed.count ?? 1;
+        const baseId = seed.id ?? seed.typeId;
+        return count > 1
+            ? Array.from({ length: count }, (_, index) => `${baseId}-${index + 1}`)
+            : [baseId];
+    });
+}
+function validateTypeSlotDuplicates(options) {
+    const issues = [];
+    for (const [index, pieceType] of options.pieceTypes.entries()) {
+        issues.push(...collectDuplicateIdIssues({
+            entries: (pieceType.slots ?? []).map((slot, slotIndex) => ({
+                id: slot.id,
+                path: `manifest.pieceTypes[${index}].slots[${slotIndex}].id`,
+            })),
+            label: "piece slot id",
+        }));
+    }
+    for (const [index, dieType] of options.dieTypes.entries()) {
+        issues.push(...collectDuplicateIdIssues({
+            entries: (dieType.slots ?? []).map((slot, slotIndex) => ({
+                id: slot.id,
+                path: `manifest.dieTypes[${index}].slots[${slotIndex}].id`,
+            })),
+            label: "die slot id",
+        }));
+    }
+    return issues;
+}
+function validateSlotHostsAndHomes(manifest) {
+    const issues = [];
+    const pieceTypesById = new Map((manifest.pieceTypes ?? []).map((pieceType) => [pieceType.id, pieceType]));
+    const dieTypesById = new Map((manifest.dieTypes ?? []).map((dieType) => [dieType.id, dieType]));
+    const slotIdsByHostKey = new Map();
+    for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
+        const pieceType = pieceTypesById.get(seed.typeId);
+        const slotIds = (pieceType?.slots ?? []).map((slot) => slot.id);
+        if (slotIds.length === 0) {
+            continue;
+        }
+        if (typeof seed.id !== "string" || seed.id.length === 0) {
+            issues.push(`manifest.pieceSeeds[${index}].id: Piece seed for slot-bearing type '${seed.typeId}' must declare an explicit id.`);
+            continue;
+        }
+        if ((seed.count ?? 1) !== 1) {
+            issues.push(`manifest.pieceSeeds[${index}].count: Piece seed '${seed.id}' for slot-bearing type '${seed.typeId}' must omit count or set it to 1.`);
+            continue;
+        }
+        slotIdsByHostKey.set(`piece:${seed.id}`, new Set(slotIds));
+    }
+    for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
+        const dieType = dieTypesById.get(seed.typeId);
+        const slotIds = (dieType?.slots ?? []).map((slot) => slot.id);
+        if (slotIds.length === 0) {
+            continue;
+        }
+        if (typeof seed.id !== "string" || seed.id.length === 0) {
+            issues.push(`manifest.dieSeeds[${index}].id: Die seed for slot-bearing type '${seed.typeId}' must declare an explicit id.`);
+            continue;
+        }
+        if ((seed.count ?? 1) !== 1) {
+            issues.push(`manifest.dieSeeds[${index}].count: Die seed '${seed.id}' for slot-bearing type '${seed.typeId}' must omit count or set it to 1.`);
+            continue;
+        }
+        slotIdsByHostKey.set(`die:${seed.id}`, new Set(slotIds));
+    }
+    const validateHome = (home, path) => {
+        if (home?.type !== "slot") {
+            return;
+        }
+        const hostKey = `${home.host.kind}:${home.host.id}`;
+        const slotIds = slotIdsByHostKey.get(hostKey);
+        if (!slotIds) {
+            issues.push(`${path}.host: Unknown strict slot host '${home.host.kind}:${home.host.id}'. Hosts must be singleton piece/die seeds whose type declares slots.`);
+            return;
+        }
+        if (!slotIds.has(home.slotId)) {
+            issues.push(`${path}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`);
+        }
+    };
+    for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
+        if (cardSet.type !== "manual") {
+            continue;
+        }
+        for (const [cardIndex, card] of cardSet.cards.entries()) {
+            validateHome(card.home, `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`);
+        }
+    }
+    for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
+        validateHome(seed.home, `manifest.pieceSeeds[${index}].home`);
+    }
+    for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
+        validateHome(seed.home, `manifest.dieSeeds[${index}].home`);
+    }
+    return issues;
+}
+function validateSetupProfileReferences(manifest) {
+    const issues = [];
+    const optionChoiceIdsByOptionId = new Map((manifest.setupOptions ?? []).map((option, optionIndex) => {
+        const choiceIds = new Set();
+        for (const choice of option.choices ?? []) {
+            choiceIds.add(choice.id);
+        }
+        if (!option.id) {
+            issues.push(`manifest.setupOptions[${optionIndex}].id: Missing option id.`);
+        }
+        return [option.id, choiceIds];
+    }));
+    for (const [profileIndex, profile] of (manifest.setupProfiles ?? []).entries()) {
+        const optionValues = profile.optionValues ?? {};
+        for (const [optionId, choiceId] of Object.entries(optionValues)) {
+            const allowedChoices = optionChoiceIdsByOptionId.get(optionId);
+            if (!allowedChoices) {
+                issues.push(`manifest.setupProfiles[${profileIndex}].optionValues.${optionId}: Unknown setup option '${optionId}'.`);
+                continue;
+            }
+            if (!allowedChoices.has(choiceId)) {
+                issues.push(`manifest.setupProfiles[${profileIndex}].optionValues.${optionId}: Unknown choice '${choiceId}' for setup option '${optionId}'.`);
+            }
+        }
+    }
+    return issues;
+}
+function validatePlayerScopedSeedHomes(manifest) {
+    const issues = [];
+    const boardScopeById = new Map((manifest.boards ?? []).map((board) => [board.id, board.scope]));
+    const zoneScopeById = new Map((manifest.zones ?? []).map((zone) => [zone.id, zone.scope]));
+    const validateSeedHome = (seed, path, label) => {
+        const authoredId = seed.id ?? seed.typeId;
+        if (seed.ownerId) {
+            return;
+        }
+        if (homeTargetsBoard(seed.home) &&
+            boardScopeById.get(seed.home.boardId) === "perPlayer") {
+            issues.push(`${path}.boardId: ${label} '${authoredId}' requires ownerId because board '${seed.home.boardId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`);
+            return;
+        }
+        if (seed.home?.type === "zone" &&
+            zoneScopeById.get(seed.home.zoneId) === "perPlayer") {
+            issues.push(`${path}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`);
+        }
+    };
+    for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
+        validateSeedHome(seed, `manifest.pieceSeeds[${index}].home`, "Piece seed");
+    }
+    for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
+        validateSeedHome(seed, `manifest.dieSeeds[${index}].home`, "Die seed");
+    }
+    return issues;
+}
+function homeTargetsBoard(home) {
+    return (home?.type === "space" ||
+        home?.type === "container" ||
+        home?.type === "edge" ||
+        home?.type === "vertex");
+}
+function validateBoardTemplateDuplicates(boardTemplates) {
+    const issues = [];
+    for (const [index, boardTemplate] of boardTemplates.entries()) {
+        if (isHexBoardTemplateSpec(boardTemplate)) {
+            issues.push(...collectDuplicateIdIssues({
+                entries: (boardTemplate.spaces ?? []).map((space, spaceIndex) => ({
+                    id: space.id,
+                    path: `manifest.boardTemplates[${index}].spaces[${spaceIndex}].id`,
+                })),
+                label: "space id",
+            }));
+            continue;
+        }
+        issues.push(...collectDuplicateIdIssues({
+            entries: (boardTemplate.spaces ?? []).map((space, spaceIndex) => ({
+                id: space.id,
+                path: `manifest.boardTemplates[${index}].spaces[${spaceIndex}].id`,
+            })),
+            label: "space id",
+        }));
+        issues.push(...collectDuplicateIdIssues({
+            entries: (boardTemplate.containers ?? []).map((container, containerIndex) => ({
+                id: container.id,
+                path: `manifest.boardTemplates[${index}].containers[${containerIndex}].id`,
+            })),
+            label: "container id",
+        }));
+        issues.push(...collectDuplicateIdIssues({
+            entries: (boardTemplate.relations ?? []).map((relation, relationIndex) => ({
+                id: relation.id,
+                path: `manifest.boardTemplates[${index}].relations[${relationIndex}].id`,
+            })),
+            label: "relation id",
+        }));
+    }
+    return issues;
+}
+function validateBoardDuplicates(boards) {
+    const issues = [];
+    for (const [index, board] of boards.entries()) {
+        if (isHexBoardSpec(board)) {
+            issues.push(...collectDuplicateIdIssues({
+                entries: (board.spaces ?? []).map((space, spaceIndex) => ({
+                    id: space.id,
+                    path: `manifest.boards[${index}].spaces[${spaceIndex}].id`,
+                })),
+                label: "space id",
+            }));
+            continue;
+        }
+        issues.push(...collectDuplicateIdIssues({
+            entries: (board.spaces ?? []).map((space, spaceIndex) => ({
+                id: space.id,
+                path: `manifest.boards[${index}].spaces[${spaceIndex}].id`,
+            })),
+            label: "space id",
+        }));
+        issues.push(...collectDuplicateIdIssues({
+            entries: (board.containers ?? []).map((container, containerIndex) => ({
+                id: container.id,
+                path: `manifest.boards[${index}].containers[${containerIndex}].id`,
+            })),
+            label: "container id",
+        }));
+        issues.push(...collectDuplicateIdIssues({
+            entries: (board.relations ?? []).map((relation, relationIndex) => ({
+                id: relation.id,
+                path: `manifest.boards[${index}].relations[${relationIndex}].id`,
+            })),
+            label: "relation id",
+        }));
+    }
+    return issues;
+}
+function validateSetupOptionChoiceDuplicates(options) {
+    const issues = [];
+    for (const [optionIndex, option] of options.entries()) {
+        issues.push(...collectDuplicateIdIssues({
+            entries: (option.choices ?? []).map((choice, choiceIndex) => ({
+                id: choice.id,
+                path: `manifest.setupOptions[${optionIndex}].choices[${choiceIndex}].id`,
+            })),
+            label: "setup option choice id",
+        }));
+    }
+    return issues;
+}
+function resolveHexSpaces(board, template) {
+    if (!template) {
+        return [...(board.spaces ?? [])].sort((left, right) => left.id.localeCompare(right.id));
+    }
+    const templateSpacesById = new Map((template.spaces ?? []).map((space) => [space.id, space]));
+    const overridesById = new Map((board.spaces ?? []).map((space) => [space.id, space]));
+    for (const overrideId of overridesById.keys()) {
+        if (!templateSpacesById.has(overrideId)) {
+            continue;
+        }
+    }
+    return (template.spaces ?? [])
+        .map((templateSpace) => {
+        const override = overridesById.get(templateSpace.id);
+        if (!override) {
+            return templateSpace;
+        }
+        return {
+            ...templateSpace,
+            ...override,
+            id: templateSpace.id,
+            q: templateSpace.q,
+            r: templateSpace.r,
+        };
+    })
+        .sort((left, right) => left.id.localeCompare(right.id));
+}
+function validateHexVertexRefs(options) {
+    const issues = [];
+    const spacesById = new Map(options.spaces.map((space) => [space.id, space]));
+    for (const [vertexIndex, vertex] of options.vertices.entries()) {
+        try {
+            resolveHexVertexGeometryKey(vertex.ref, spacesById);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown hex vertex error.";
+            issues.push(`${options.ownerPath}.vertices[${vertexIndex}].ref: ${options.ownerLabel} with spaces '${vertex.ref.spaces.join(", ")}' failed validation. ${message}`);
+        }
+    }
+    return issues;
+}
+function validateHexBoardVertexRefs(manifest) {
+    const issues = [];
+    const hexTemplatesById = new Map((manifest.boardTemplates ?? [])
+        .filter(isHexBoardTemplateSpec)
+        .map((boardTemplate) => [boardTemplate.id, boardTemplate]));
+    for (const [templateIndex, template] of (manifest.boardTemplates ?? []).entries()) {
+        if (!isHexBoardTemplateSpec(template)) {
+            continue;
+        }
+        issues.push(...validateHexVertexRefs({
+            ownerPath: `manifest.boardTemplates[${templateIndex}]`,
+            ownerLabel: `Hex board template '${template.id}'`,
+            spaces: template.spaces ?? [],
+            vertices: template.vertices ?? [],
+        }));
+    }
+    for (const [boardIndex, board] of (manifest.boards ?? []).entries()) {
+        if (!isHexBoardSpec(board)) {
+            continue;
+        }
+        issues.push(...validateHexVertexRefs({
+            ownerPath: `manifest.boards[${boardIndex}]`,
+            ownerLabel: `Hex board '${board.id}'`,
+            spaces: resolveHexSpaces(board, hexTemplatesById.get(board.templateId ?? "")),
+            vertices: board.vertices ?? [],
+        }));
+    }
+    return issues;
+}
+function collectAmbiguousBoardTypeWarnings(manifest) {
+    const warnings = [];
+    const boardTemplatesById = new Map((manifest.boardTemplates ?? []).map((template) => [template.id, template]));
+    const boardsBySpaceType = new Map();
+    const boardsByEdgeType = new Map();
+    const boardsByVertexType = new Map();
+    const addBoardUsage = (target, typeId, boardId) => {
+        if (!typeId) {
+            return;
+        }
+        const boardIds = target.get(typeId) ?? new Set();
+        boardIds.add(boardId);
+        target.set(typeId, boardIds);
+    };
+    for (const board of manifest.boards ?? []) {
+        const template = board.templateId
+            ? boardTemplatesById.get(board.templateId)
+            : undefined;
+        for (const space of [
+            ...((template?.layout === board.layout ? template.spaces : undefined) ??
+                []),
+            ...(board.spaces ?? []),
+        ]) {
+            addBoardUsage(boardsBySpaceType, space.typeId, board.id);
+        }
+        if (board.layout === "hex" || board.layout === "square") {
+            for (const edge of [
+                ...((template?.layout === board.layout ? template.edges : undefined) ??
+                    []),
+                ...(board.edges ?? []),
+            ]) {
+                addBoardUsage(boardsByEdgeType, edge.typeId, board.id);
+            }
+            for (const vertex of [
+                ...((template?.layout === board.layout
+                    ? template.vertices
+                    : undefined) ?? []),
+                ...(board.vertices ?? []),
+            ]) {
+                addBoardUsage(boardsByVertexType, vertex.typeId, board.id);
+            }
+        }
+    }
+    const pushWarnings = (kind, boardsByType, helperName) => {
+        for (const [typeId, boardIds] of boardsByType.entries()) {
+            if (boardIds.size < 2) {
+                continue;
+            }
+            warnings.push(`Ambiguous ${kind}.typeId '${typeId}' is authored on multiple boards (${Array.from(boardIds).sort().join(", ")}). Prefer ${helperName} for board-scoped lookups.`);
+        }
+    };
+    pushWarnings("space", boardsBySpaceType, "boardHelpers.spaceIdsByBoardId / boardHelpers.spaceTypeIdByBoardId");
+    pushWarnings("edge", boardsByEdgeType, "boardHelpers.edgeIdsByBoardIdAndTypeId");
+    pushWarnings("vertex", boardsByVertexType, "boardHelpers.vertexIdsByBoardIdAndTypeId");
+    return warnings;
+}
+export function validateManifestAuthoring(manifest) {
+    const errors = [];
+    errors.push(...collectDuplicateIdIssues({
+        entries: manifest.cardSets.map((cardSet, index) => ({
+            id: cardSet.id,
+            path: `manifest.cardSets[${index}].id`,
+        })),
+        label: "card set id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: manifest.cardSets.flatMap((cardSet, cardSetIndex) => cardSet.type === "manual"
+            ? cardSet.cards.flatMap((card, cardIndex) => renderCardInstanceIds(card).map((cardId) => ({
+                id: cardId,
+                path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].type`,
+            })))
+            : []),
+        label: "card runtime id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.zones ?? []).map((zone, index) => ({
+            id: zone.id,
+            path: `manifest.zones[${index}].id`,
+        })),
+        label: "zone id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.boardTemplates ?? []).map((boardTemplate, index) => ({
+            id: boardTemplate.id,
+            path: `manifest.boardTemplates[${index}].id`,
+        })),
+        label: "board template id",
+    }));
+    errors.push(...validateBoardTemplateDuplicates(manifest.boardTemplates ?? []));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.boards ?? []).map((board, index) => ({
+            id: board.id,
+            path: `manifest.boards[${index}].id`,
+        })),
+        label: "board id",
+    }));
+    errors.push(...validateBoardDuplicates(manifest.boards ?? []));
+    errors.push(...validateTypeSlotDuplicates({
+        pieceTypes: manifest.pieceTypes ?? [],
+        dieTypes: manifest.dieTypes ?? [],
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.pieceTypes ?? []).map((pieceType, index) => ({
+            id: pieceType.id,
+            path: `manifest.pieceTypes[${index}].id`,
+        })),
+        label: "piece type id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: expandSeedIds(manifest.pieceSeeds ?? []).map((pieceId, index) => ({
+            id: pieceId,
+            path: `manifest.pieceSeeds[*][${index}]`,
+        })),
+        label: "piece runtime id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.dieTypes ?? []).map((dieType, index) => ({
+            id: dieType.id,
+            path: `manifest.dieTypes[${index}].id`,
+        })),
+        label: "die type id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: expandSeedIds(manifest.dieSeeds ?? []).map((dieId, index) => ({
+            id: dieId,
+            path: `manifest.dieSeeds[*][${index}]`,
+        })),
+        label: "die runtime id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.resources ?? []).map((resource, index) => ({
+            id: resource.id,
+            path: `manifest.resources[${index}].id`,
+        })),
+        label: "resource id",
+    }));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.setupOptions ?? []).map((option, index) => ({
+            id: option.id,
+            path: `manifest.setupOptions[${index}].id`,
+        })),
+        label: "setup option id",
+    }));
+    errors.push(...validateSetupOptionChoiceDuplicates(manifest.setupOptions ?? []));
+    errors.push(...collectDuplicateIdIssues({
+        entries: (manifest.setupProfiles ?? []).map((profile, index) => ({
+            id: profile.id,
+            path: `manifest.setupProfiles[${index}].id`,
+        })),
+        label: "setup profile id",
+    }));
+    errors.push(...validateSlotHostsAndHomes(manifest));
+    errors.push(...validatePlayerScopedSeedHomes(manifest));
+    errors.push(...validateSetupProfileReferences(manifest));
+    errors.push(...validateHexBoardVertexRefs(manifest));
+    return {
+        errors,
+        warnings: collectAmbiguousBoardTypeWarnings(manifest),
+    };
+}

package/dist/ownership.d.ts

@@ -0,0 +1,31 @@
+export type OwnershipPattern = {
+    prefix: string;
+    suffix: string;
+};
+export type ScaffoldingOwnership = {
+    version: number;
+    allowedPaths: {
+        rootFiles: string[];
+        directoryPrefixes: string[];
+    };
+    dynamic: {
+        generatedFiles: string[];
+        seedFiles: string[];
+        seedFilePatterns: OwnershipPattern[];
+    };
+    cliStatic: {
+        exactFiles: string[];
+        directoryPrefixes: string[];
+    };
+    preservedUserFiles: string[];
+};
+export declare const WORKSPACE_CODEGEN_OWNERSHIP: ScaffoldingOwnership;
+export declare const AUTHORITATIVE_GENERATED_FILES: string[];
+export declare const SEED_FILES: string[];
+export declare const SEED_FILE_PATTERNS: OwnershipPattern[];
+export declare const PRESERVED_USER_FILES: Set<string>;
+export declare function isAllowedGamePath(filePath: string): boolean;
+export declare function isAuthoritativeGeneratedPath(filePath: string): boolean;
+export declare function isDynamicSeedPath(filePath: string): boolean;
+export declare function isCliStaticPath(filePath: string): boolean;
+export declare function isLibraryPath(filePath: string): boolean;

package/dist/ownership.js

@@ -0,0 +1,86 @@
+export const WORKSPACE_CODEGEN_OWNERSHIP = {
+    version: 26,
+    allowedPaths: {
+        rootFiles: [
+            ".npmrc",
+            "package.json",
+            "pnpm-lock.yaml",
+            "package-lock.json",
+            "manifest.ts",
+            "manifest.tsconfig.json",
+            "rule.md",
+        ],
+        directoryPrefixes: ["app/", "ui/", "shared/", "test/"],
+    },
+    dynamic: {
+        generatedFiles: [
+            "shared/manifest-literals.ts",
+            "shared/manifest-types.ts",
+            "shared/manifest-runtime.ts",
+            "shared/manifest-contract.ts",
+            "shared/generated/ui-contract.ts",
+            "app/index.ts",
+            "app/tsconfig.framework.json",
+            "ui/tsconfig.framework.json",
+        ],
+        seedFiles: [
+            "app/README.md",
+            "ui/App.tsx",
+            "app/game-contract.ts",
+            "app/game.ts",
+            "app/setup-profiles.ts",
+            "app/reducer-support.ts",
+            "app/derived.ts",
+        ],
+        seedFilePatterns: [{ prefix: "app/phases/", suffix: ".ts" }],
+    },
+    cliStatic: {
+        exactFiles: [
+            ".npmrc",
+            "package.json",
+            "app/tsconfig.json",
+            "ui/index.tsx",
+            "ui/package.json",
+            "ui/style.css",
+            "ui/tsconfig.json",
+        ],
+        directoryPrefixes: [],
+    },
+    preservedUserFiles: [],
+};
+export const AUTHORITATIVE_GENERATED_FILES = WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles;
+export const SEED_FILES = WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles;
+export const SEED_FILE_PATTERNS = WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFilePatterns;
+export const PRESERVED_USER_FILES = new Set(WORKSPACE_CODEGEN_OWNERSHIP.preservedUserFiles);
+function normalizeProjectPath(filePath) {
+    return filePath.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/");
+}
+export function isAllowedGamePath(filePath) {
+    const path = normalizeProjectPath(filePath);
+    if (WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.rootFiles.includes(path)) {
+        return true;
+    }
+    return WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.directoryPrefixes.some((prefix) => path.startsWith(prefix));
+}
+export function isAuthoritativeGeneratedPath(filePath) {
+    const path = normalizeProjectPath(filePath);
+    return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles.includes(path);
+}
+export function isDynamicSeedPath(filePath) {
+    const path = normalizeProjectPath(filePath);
+    if (WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles.includes(path)) {
+        return true;
+    }
+    return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFilePatterns.some((pattern) => path.startsWith(pattern.prefix) && path.endsWith(pattern.suffix));
+}
+export function isCliStaticPath(filePath) {
+    const path = normalizeProjectPath(filePath);
+    if (WORKSPACE_CODEGEN_OWNERSHIP.cliStatic.exactFiles.includes(path)) {
+        return true;
+    }
+    return WORKSPACE_CODEGEN_OWNERSHIP.cliStatic.directoryPrefixes.some((prefix) => path.startsWith(prefix));
+}
+export function isLibraryPath(filePath) {
+    const path = normalizeProjectPath(filePath);
+    return isAuthoritativeGeneratedPath(path);
+}

package/dist/preset-card-sets.d.ts

@@ -0,0 +1,5 @@
+import type { GameTopologyManifest, ManualCardSetDefinition, PresetCardSetDefinition } from "@dreamboard/sdk-types";
+export declare function createStandard52CardDeck(): ManualCardSetDefinition;
+export declare function addStandardDecksIfNeeded(manifest: GameTopologyManifest): GameTopologyManifest;
+export declare function materializePresetCardSet(presetCardSet: PresetCardSetDefinition): ManualCardSetDefinition;
+export declare function materializeCardSet(cardSet: GameTopologyManifest["cardSets"][number]): ManualCardSetDefinition;