@playcraft/cli 0.1.61-beta → 0.1.63

package/dist/workspace-runtime/workspaces/procedural-3d/read-candidates.js

@@ -0,0 +1,219 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { workspaceModelCandidateListSchema, workspaceModelCandidateSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { checkedFile, dependencyHash, digest, relativeFile } from './files.js';
+import { ModelPreviewStore } from './model-preview-store.js';
+const hash = z.string().regex(/^[a-f0-9]{64}$/);
+const fileSchema = z.object({ path: z.string().refine(value => {
+        try {
+            relativeFile(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }), hash });
+const candidateSchema = z.object({ id: z.string().uuid(), files: z.array(fileSchema).min(1).max(256),
+    sourcePaths: z.array(z.string()).min(1).max(128), sourceHash: hash, dependencyHash: hash,
+    pagePath: z.string(), specHash: hash, passId: z.string().min(1).max(128),
+    captures: z.array(fileSchema.extend({ view: z.string().min(1).max(64) })).max(16).optional(),
+    hostReview: z.object({ profileHash: hash }).optional(),
+    review: z.object({ decision: z.enum(['accept', 'revise']), sourceHash: hash }).optional(),
+    adoptedPath: z.string().optional() });
+const runSchema = z.object({ schemaVersion: z.literal(1), runId: z.string().uuid(),
+    revision: z.number().int().nonnegative(), root: z.string(), artifactHash: hash,
+    referenceHash: hash, referencePath: z.string(), candidates: z.array(z.unknown()) });
+const MAX_RUNS = 64;
+const MAX_CANDIDATES = 128;
+const MAX_BYTES = 256 * 1024 * 1024;
+/** Read control-owned snapshots without invoking the Skill or changing a completed run. */
+export async function readProceduralModelCandidates(root, stateDir) {
+    const result = { schemaVersion: 1, candidates: [], diagnostics: [],
+        truncated: false, scannedAt: new Date().toISOString() };
+    const controlRelative = `procedural-3d/${digest(root)}`;
+    const controlDirectory = join(stateDir, controlRelative);
+    const diagnose = (code, runId, candidateId) => {
+        if (result.diagnostics.length < 256)
+            result.diagnostics.push({ code, ...(runId ? { runId } : {}), ...(candidateId ? { candidateId } : {}) });
+        else
+            result.truncated = true;
+    };
+    let names;
+    try {
+        const info = await lstat(controlDirectory);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error('model_candidates_control_invalid');
+        names = (await readdir(controlDirectory)).filter(name => /^[a-f0-9-]{36}\.json$/i.test(name)).sort();
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            diagnose('model_candidates_control_unavailable');
+        return result;
+    }
+    if (names.length > MAX_RUNS) {
+        result.truncated = true;
+        diagnose('model_candidates_run_limit');
+    }
+    let inspectedBytes = 0;
+    let inspectedCandidates = 0;
+    const seenCandidates = new Set();
+    const readBounded = async (base, path) => {
+        if (inspectedBytes >= MAX_BYTES)
+            throw new Error('model_candidates_byte_limit');
+        const bytes = await checkedFile(base, path, Math.min(16 * 1024 * 1024, MAX_BYTES - inspectedBytes));
+        inspectedBytes += bytes.length;
+        return bytes;
+    };
+    let currentDependencyHash;
+    try {
+        currentDependencyHash = await dependencyHash(root);
+    }
+    catch { /* Each candidate remains visible with a diagnostic. */ }
+    for (const name of names.slice(0, MAX_RUNS)) {
+        const runId = name.slice(0, -5);
+        if (!z.string().uuid().safeParse(runId).success) {
+            diagnose('model_candidates_run_invalid');
+            continue;
+        }
+        let run;
+        try {
+            run = runSchema.parse(JSON.parse((await checkedFile(stateDir, `${controlRelative}/${name}`, 4 * 1024 * 1024)).toString('utf8')));
+            if (run.root !== root || run.runId !== runId)
+                throw new Error('model_candidates_scope_mismatch');
+        }
+        catch {
+            diagnose('model_candidates_run_invalid', runId);
+            continue;
+        }
+        const jobRelative = `.playcraft/procedural-3d/runs/${runId}`;
+        const jobRoot = join(root, jobRelative);
+        let referenceVerified = false;
+        try {
+            referenceVerified = digest(await readBounded(jobRoot, run.referencePath)) === run.referenceHash;
+        }
+        catch { /* Reported against every affected candidate, without exposing filesystem errors. */ }
+        for (const raw of run.candidates) {
+            if (inspectedCandidates++ >= MAX_CANDIDATES) {
+                result.truncated = true;
+                diagnose('model_candidates_candidate_limit', runId);
+                break;
+            }
+            if (result.candidates.length >= MAX_CANDIDATES) {
+                result.truncated = true;
+                diagnose('model_candidates_candidate_limit', runId);
+                break;
+            }
+            const parsed = candidateSchema.safeParse(raw);
+            if (!parsed.success) {
+                diagnose('model_candidates_candidate_invalid', runId);
+                continue;
+            }
+            const candidate = parsed.data;
+            if (seenCandidates.has(`${runId}:${candidate.id}`)) {
+                diagnose('model_candidates_candidate_duplicate', runId, candidate.id);
+                continue;
+            }
+            seenCandidates.add(`${runId}:${candidate.id}`);
+            const candidatePrefix = `${jobRelative}/candidates/${candidate.id}`;
+            const source = new Set(candidate.sourcePaths);
+            try {
+                relativeFile(candidate.pagePath);
+                if (candidate.adoptedPath)
+                    relativeFile(candidate.adoptedPath);
+                if (new Set(candidate.files.map(file => file.path)).size !== candidate.files.length ||
+                    new Set(candidate.captures?.map(file => file.path)).size !== (candidate.captures?.length ?? 0) ||
+                    candidate.sourcePaths.some(path => !candidate.files.some(file => file.path === path)) ||
+                    !candidate.files.some(file => file.path === candidate.pagePath) ||
+                    candidate.captures?.some(file => !file.path.startsWith(`candidates/${candidate.id}/captures/`)))
+                    throw new Error('model_candidates_manifest_invalid');
+            }
+            catch {
+                diagnose('model_candidates_manifest_invalid', runId, candidate.id);
+                continue;
+            }
+            const item = {
+                runId, candidateId: candidate.id, revision: run.revision, passId: candidate.passId,
+                sourceHash: candidate.sourceHash, dependencyHash: candidate.dependencyHash,
+                referenceHash: run.referenceHash, skillArtifactHash: run.artifactHash,
+                files: candidate.files.map(file => ({ path: `${candidatePrefix}/source/${file.path}`, contentHash: file.hash, source: source.has(file.path) })),
+                captures: (candidate.captures ?? []).map(file => ({ path: `${jobRelative}/${file.path}`, contentHash: file.hash, view: file.view })),
+                preview: { kind: 'scene-preview', status: 'needs-build', entryPath: `${candidatePrefix}/source/${candidate.pagePath}`,
+                    sourceHash: candidate.sourceHash, dependencyHash: candidate.dependencyHash,
+                    ...(candidate.hostReview ? { profileHash: candidate.hostReview.profileHash } : {}), reason: 'candidate_scene_not_built' },
+                integrity: 'verified', ...(candidate.review ? { review: candidate.review } : {}),
+                ...(candidate.adoptedPath ? { adoptedPath: candidate.adoptedPath } : {}),
+            };
+            const invalidate = (code) => {
+                item.integrity = 'invalid';
+                if (item.preview.kind === 'scene-preview') {
+                    item.preview.status = 'unavailable';
+                    item.preview.reason = code;
+                }
+                diagnose(code, runId, candidate.id);
+            };
+            if (!workspaceModelCandidateSchema.safeParse(item).success) {
+                diagnose('model_candidates_manifest_invalid', runId, candidate.id);
+                continue;
+            }
+            if (!referenceVerified)
+                invalidate('model_candidates_reference_changed');
+            if (currentDependencyHash !== candidate.dependencyHash)
+                invalidate('model_candidates_dependencies_changed');
+            if (digest(JSON.stringify(candidate.files.map(({ path, hash }) => ({ path, hash })))) !== candidate.sourceHash)
+                invalidate('model_candidates_source_hash_changed');
+            if (!candidate.captures?.length)
+                invalidate('model_candidates_captures_missing');
+            if (candidate.review && candidate.review.sourceHash !== candidate.sourceHash)
+                invalidate('model_candidates_review_changed');
+            try {
+                if (digest(await readBounded(root, `${candidatePrefix}/spec.json`)) !== candidate.specHash)
+                    invalidate('model_candidates_spec_changed');
+            }
+            catch {
+                invalidate('model_candidates_spec_unavailable');
+            }
+            for (const file of [...item.files, ...item.captures]) {
+                try {
+                    const bytes = await readBounded(root, file.path);
+                    file.size = bytes.length;
+                    if (digest(bytes) !== file.contentHash)
+                        throw new Error('model_candidates_file_changed');
+                }
+                catch (error) {
+                    const limit = inspectedBytes >= MAX_BYTES || (error instanceof Error && error.message === 'model_candidates_byte_limit');
+                    invalidate(limit ? 'model_candidates_byte_limit' : 'model_candidates_file_unavailable');
+                    if (limit) {
+                        result.truncated = true;
+                        break;
+                    }
+                }
+            }
+            result.candidates.push(item);
+            if (item.integrity === 'verified' && item.preview.kind === 'scene-preview') {
+                try {
+                    const versions = await new ModelPreviewStore(stateDir, root).versions(item), preview = versions[0];
+                    item.previewVersions = versions.map(version => ({ previewId: version.previewId, contentHash: version.contentHash,
+                        createdAt: version.createdAt, ...(version.parameters ? { parameters: version.parameters } : {}),
+                        ...(version.parameterHash ? { parameterHash: version.parameterHash } : {}) }));
+                    if (preview)
+                        Object.assign(item.preview, { status: 'ready', reason: 'candidate_scene_built',
+                            previewId: preview.previewId, contentHash: preview.contentHash,
+                            ...(preview.parameters ? { parameters: preview.parameters } : {}),
+                            ...(preview.parameterHash ? { parameterHash: preview.parameterHash } : {}) });
+                }
+                catch {
+                    invalidate('model_preview_receipt_invalid');
+                }
+            }
+            if (inspectedBytes >= MAX_BYTES)
+                break;
+        }
+        if (inspectedBytes >= MAX_BYTES || inspectedCandidates >= MAX_CANDIDATES) {
+            result.truncated = true;
+            diagnose(inspectedBytes >= MAX_BYTES ? 'model_candidates_byte_limit' : 'model_candidates_candidate_limit', runId);
+            break;
+        }
+    }
+    return workspaceModelCandidateListSchema.parse(result);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.61-beta",
+  "version": "0.1.63",
   "private": false,
   "type": "module",
   "engines": {
@@ -53,8 +53,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "0.1.61-beta",
-    "@playcraft/common": "0.1.61-beta",
+    "@playcraft/build": "0.1.63",
+    "@playcraft/common": "0.1.63",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
@@ -91,6 +91,7 @@
     "@types/update-notifier": "^6.0.8",
     "@types/ws": "^8.18.1",
     "esbuild": "^0.28.1",
+    "three": "^0.183.2",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   }

package/project-template/.claude/skills/playcraft-runtime-parameters/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: playcraft-runtime-parameters
-description: Initialize or extend configurable parameters in a Cloud Workspace game by extracting real controls, connecting production consumers and a separate development preview, and generating the platform parameter panel from the project declarations.
+description: Initialize or extend configurable parameters in a Cloud Workspace game by extracting real controls and player-visible text, connecting production consumers and a separate development preview, and generating the platform parameter panel from the project declarations.
 compatibility: agent,opencode
-version: 1.0.0
+version: 1.1.0
 surfaces:
   - sandbox-agent
 ---
@@ -21,9 +21,19 @@ Create or extend the schema, sparse theme overrides and platform labels. Connect
 
 For each consumed field, select an honest application mode: `live` for an in-place change, `restart-scene` for a change requiring a new game or scene, or `reload` when a new build is necessary. Register only real consumers. At least one meaningful live consumer should be connected when the game supports it; do not mark every field live to make initialization appear successful. Reuse the existing game's start/reset/dispose lifecycle for a restart.
 
+## Localize player-visible text
+
+Games usually ship literal strings. By default, initialization also moves a small set of the text a player really sees into platform runtime text, so the panel can edit it per language and the preview can switch its language. Pick the most visible lines (the title, the primary call to action, key instructions or result messages), at most eight keys; text keys count as candidates in the same bounded first group. Author them with the text rules in the parameter protocol and register them as described in the integration reference.
+
+- Extract only text that a real consumer displays and that can be refreshed in place. Skip text baked into images, identifiers, file names, analytics events and any string the game compares or parses.
+- Keep the English default identical to what the game displayed before the change, and write real translations for the other seventeen languages. Keep placeholders and format tokens (for example `[remaining]` or `{count}`) unchanged in every language, and keep existing pluralization or ordering logic working.
+- A game that already localizes its text keeps its own keys, files and language detection; do not add a parallel text system beside it.
+- Finish a text candidate completely (shared resolver, production and preview consumers, tests) or do not add it. An unfinished candidate keeps the whole initialization from verifying, so leave text you cannot finish unchanged and say so in the final response instead of reporting it as blocked.
+- If the game cannot refresh any text in place, keep its text unchanged rather than registering a language switch that does not work.
+
 ## Validate the generated project
 
-Add or extend `test:parameters` with executable checks for defaults, sparse overrides and changed real-consumer behavior. Keep or restore a successful production `build`; retain an existing `typecheck`. Use the separate preview entry and production release boundary described in the integration reference.
+Add or extend `test:parameters` with executable checks for defaults, sparse overrides and changed real-consumer behavior. For text, also check that every referenced key has all eighteen languages in the global file, that a theme entry wins over the global one, that a blank string stays blank, that a missing language never borrows English, and that production and preview resolve the same text. Keep or restore a successful production `build`; retain an existing `typecheck`. Use the separate preview entry and production release boundary described in the integration reference.
 
 The platform runs its own checks, builds the first development preview and derives capabilities from the real handshake. Report concrete incomplete work when the project cannot be adapted; do not fabricate receipts, successful builds or live capability. Preserve reviewable partial changes on failure.
 

package/project-template/.claude/skills/playcraft-runtime-parameters/references/platform-protocol.md

@@ -19,3 +19,15 @@ Image, video and other resource leaves retain `xplatform.value_type: "path"` plu
 Game text retains `xplatform.value_type: "i18n"` and an `i18n.runtime.<key>` reference. Keep global `i18n.runtime.json5` and per-theme `theme.i18n.runtime.json5` semantics and export the text from the real theme entry used in production. Supported languages are `en`, `zh`, `zh-TW`, `de`, `fr`, `es`, `ja`, `ko`, `pt`, `it`, `hi`, `bn`, `ur`, `ar`, `tr`, `ru`, `ms`, `id`. Keep complete language maps for overridden keys and remove an override only when its full value matches the inherited default. Explicit blank strings remain blank rather than falling back to another language.
 
 Arrays, complex structures and unsupported constraints keep their original meaning. Do not disguise them as ordinary primitive controls to obtain a writable panel. An initialization can leave such controls explicitly unsupported while connecting a useful supported set.
+
+## Authoring new game text
+
+Use this when text the player sees is still a literal in the game. Text the game already exports through its own localization keeps those keys and files.
+
+- **Schema leaf.** `type: "string"`, `default: "i18n.runtime.<key>"`, `xplatform.value_type: "i18n"`, plus the usual platform label. `<key>` is one flat identifier (letters and digits, at most 128 characters, no dots) that names the purpose, such as `headerTitle` or `downloadButton`, not the English wording. A key and its leaf are unique. Theme data does not receive this leaf's value and never contains translated text.
+- **Global defaults.** `i18n.runtime.json5` in the same directory as the schema file. Each key maps every one of the eighteen languages to a string of at most 4096 characters; a key with fewer or more languages is invalid and its field stays disabled. The `en` entry equals the literal the game displayed before, so default behavior and visuals do not change.
+- **Theme overrides.** `theme.i18n.runtime.json5` sits in the same directory as the theme data file and stays sparse. Do not create it for new text: the platform writes it on the first edit and removes a key again when all of its languages match the global default. Keep an existing file untouched.
+- **Report evidence.** The global file, and the theme file when it exists, belong in the report `sources` of every text candidate. The candidate `fieldPath` is the schema leaf path; its origin names where the literal used to live, and its consumers name the code that now displays the resolved text.
+- **Resolution.** Production and preview share one pure function: the theme map when the theme has the key, otherwise the global map; read only the selected language. A missing key or language yields an empty string. Never fall back to English or another language, and keep an explicit blank as blank. Do not mutate either document.
+- **Language selection.** The preview supplies the selected language (see the integration reference). Production keeps the project's own language detection; a project with none uses the `lng` query parameter, then the browser language, then `en`. Normalize to a supported language by exact match, then base language, then `en`; `zh-TW` is a separate language from `zh`.
+- **Delivery.** Production loads both files through its real theme or configuration entry so the delivered package under `dist/` contains the text it needs.

package/project-template/.claude/skills/playcraft-runtime-parameters/references/preview-integration.md

@@ -17,6 +17,7 @@ Import `connectPreviewRuntime` and `readWorkspacePreviewContext` from the copied
 - `createGame(context)` returns real `apply`, `restartScene`, `afterRender` and `dispose` behavior. Honor `context.signal` and `context.assertCurrent()` before asynchronous visible changes. `afterRender` waits for a real frame.
 - Live changes preserve progress and object identity where appropriate. Scene restart uses the game's own lifecycle and disposes obsolete objects, timers, event handlers and owned resources.
 - Image consumers use `resource: "image"`, logical paths and `context.loadImage`. Prepare before installation, retain the previous image on a recoverable load failure, and honor explicit same-path refreshes. See the copied guide for resource error and lifecycle behavior.
+- Localized text registers each refreshable `runtimeI18n` key and the `previewContext.locale` language context as `live` fields, resolves with the production rule (selected language only, no cross-language fallback) and updates existing text objects in place. The preview language switch exists only when `previewContext.locale` is registered `live`. See the copied guide for the document shapes and which transported keys to trust.
 
 Do not route development updates through an advertising configuration cache. Real field registration and a version-matched handshake establish capability; an integration report cannot do so.
 

package/project-template-v2/.playcraft/skills.lock.json

@@ -157,8 +157,8 @@
     },
     {
       "skillRef": "remix/playcraft-runtime-parameters",
-      "version": "1.0.0",
-      "artifactHash": "629de8166ca49e4cd3a8797607dcbe1ee378177a743371c96896c4cd7ad1468d",
+      "version": "1.1.0",
+      "artifactHash": "1cef081cdb9aa9861ea6c5b5142c9adc08d2c63615bf0b37bf35c71f3459d1f0",
       "surface": "sandbox-agent",
       "mountPath": ".playcraft/skills/remix__playcraft-runtime-parameters"
     },

package/project-templates/empty/AGENTS.md

@@ -65,7 +65,7 @@ The artifact panel shows final deliverables under `dist/` at the current project
 
 When a generated asset is ready for delivery, save or copy it into `dist/` with a stable relative path. Keep the resources required by a model or document within `dist/` and preserve their relative links. Reuse the same delivery path for a revised artifact so its versions remain grouped; the platform retains its history. Use different paths for independent candidates or deliverables.
 
-Run playable builds from the project root (`playcraft build --mode full --platform playcraft --format html .`). In a workspace this command builds in an isolated copy, validates the result, and retains the playable at `dist/playable/index.html` while preserving other deliverables. A successful agent command or turn that writes a valid self-contained HTML (HyperText Markup Language, 超文本标记语言) file at this same path is collected as the same playable preview. No separate publish action is required to view it. A base build's `dist/index.html` can still require resource files and remains a document. The page's generate-preview action rebuilds the current project through the same validation. Public sharing is a separate explicit action. Temporary `.playcraft-preview-out/` and `.playcraft-temp/` files are not deliverables. Preserve other artifacts already in `dist/` when rebuilding a playable.
+Run playable builds from the project root (`playcraft build --mode full --platform playcraft --format html .`). In a workspace this command builds in an isolated copy, validates the result, and retains the playable at `dist/playable/index.html` while preserving other deliverables. A successful agent command or turn that writes a valid self-contained HTML (HyperText Markup Language, 超文本标记语言) file at this same path is collected as the same playable preview. No separate publish action is required to view it. A base build's `dist/index.html` can still require resource files and remains a document. The page's generate-preview action rebuilds the current project through the same validation. After a successful build the command also publishes the playable and prints `Public URL: <address>`; when you report the build, link that address as the playable instead of the sandbox path, since it opens directly and can be shared. If the command prints `Public URL unavailable`, report that the build succeeded without a public address and give the reason it printed. Temporary `.playcraft-preview-out/` and `.playcraft-temp/` files are not deliverables. Preserve other artifacts already in `dist/` when rebuilding a playable.
 
 Keep this convention in `AGENTS.md`, the project's standard instruction filename. Do not create a separate `AGENT.md`.
 

package/templates/preview-runtime/v1/README.md

@@ -26,6 +26,26 @@ The endpoint advertises `canRefreshImages: true` for explicit same-path content
 
 Content generations are independent per field. If an opening image and board image are being prepared together, a newer board-only refresh cancels only the old board read; the still-current opening image must finish and apply while preserving the newer board. Each application uses only the prepared fields that remain current and the latest permitted configuration. A preparation failure in a still-current batch retains the old images and marks all its unapplied fields as recoverable, so an explicit retry cannot silently forget a prepared sibling.
 
+## Localized text parameters
+
+A game whose player-visible text is exported as `i18n.runtime.<key>` references registers each key it can really refresh, plus the language context. Use one group id (for example `localized-text`) for all of them:
+
+```ts
+{ documentId: 'runtimeI18n', path: ['headerTitle'], effectivePath: ['gamePlay', 'sections', 'top', 'title'], groupId: 'localized-text', mode: 'live' },
+{ documentId: 'previewContext', path: ['locale'], effectivePath: ['previewLocale'], groupId: 'localized-text', mode: 'live' },
+```
+
+`path` is the flat text key; `effectivePath` is where the resolved text lands in the game's own configuration. The platform's preview-language switch is enabled only when `previewContext.locale` is registered as `live`, so register it only when the text really refreshes in place; without it the switch stays disabled.
+
+Documents reaching `resolve(documents)`, `source.install` and the `apply` configuration:
+
+- `documents.previewContext.locale` is the language selected in the panel, one of the eighteen supported languages. Normalize it defensively. `binding.locale` is the fixed session contract value and is not the selected language.
+- `documents.runtimeI18n[key]` is `{ [selectedLanguage]: text }`, with the inherited global text already filled in. It never contains another language, so a missing entry means an empty string; do not fall back to English or another language.
+- The snapshot can include keys the game did not register. Take transported text only for the keys you registered; every other key keeps the text bundled in this build.
+- Resolve through the same pure function as production. Do not mutate the documents.
+
+In `apply`, when `context.fields` contains a `localized-text` field, update the existing text objects (`setText`, relayout) rather than recreating the scene, and keep progress, timers, animations and the current screen. Check `context.assertCurrent()` before late side effects, and let `afterRender` wait for the real frame. An empty string is a valid value: hide or collapse the element cleanly instead of showing a placeholder or the key.
+
 ## Preview build
 
 The engineering project must install a compatible Vite as a development dependency. Set a separate package script:

package/templates/preview-runtime/v1/manifest.json

@@ -4,7 +4,7 @@
   "protocolVersion": 1,
   "files": {
     "build-preview.mjs": "2bd512675d829cc07ceddcb58365a6f74d36ff93690f8d72f4bbaa1d45511c91",
-    "README.md": "3e35ca2ce6eab84ba8688b400aee8ee5e69458466a13f00e459fd630575d9cbd",
+    "README.md": "907bb956f939b3d957ba83789e6131b2f4366fb22a239acda776df4ed22b7db2",
     "release-guard.mjs": "0c33d1559c68844f3760c3e754ee36ca70dc27151ef6f7ad62f29f95239679cc",
     "runtime.d.mts": "a366552166a4a93103306997058951416740eaf6d6f3d0a34854386b4f1e02f5",
     "runtime.d.ts": "a366552166a4a93103306997058951416740eaf6d6f3d0a34854386b4f1e02f5",