@chrona-city/ugc-kit 1.5.10 → 1.5.12
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +16 -0
- package/contracts/ugc/public-runtime/v1/README.md +40 -0
- package/contracts/ugc/public-runtime/v1/archive.mjs +4 -3
- package/contracts/ugc/public-runtime/v1/manifest.mjs +21 -10
- package/contracts/ugc/public-runtime/v1/runtime-manifest.schema.json +60 -16
- package/contracts/ugc/public-runtime/v1/static-room-runtime.test.mjs +225 -0
- package/docs/harness-onboarding.md +6 -3
- package/docs/npm-creator.md +1 -1
- package/docs/runtime-download.md +69 -0
- package/lib/creator-api.mjs +10 -9
- package/lib/creator-contribution.mjs +1 -1
- package/lib/creator-onboarding.mjs +3 -2
- package/lib/creator-platform.mjs +4 -2
- package/lib/creator-project-update.mjs +4 -1
- package/lib/creator-session.mjs +6 -5
- package/lib/creator-toolchain-compat.mjs +6 -0
- package/lib/host-ipc/{distribution-node-support-contract → distribution-static-room-semantic-contract}/contracts/ugc/public-runtime/v1/manifest.mjs +21 -10
- package/lib/host-ipc/{distribution-node-support-contract → distribution-static-room-semantic-contract}/contracts/ugc/public-runtime/v1/runtime-manifest.schema.json +60 -16
- package/lib/host-ipc/host-ipc.schema.json +18 -2
- package/lib/host-ipc/runtime-contract.mjs +5 -5
- package/lib/host-ipc/source-lock.json +9 -9
- package/lib/runtime-host-client.mjs +10 -4
- package/lib/runtime-host.mjs +3 -1
- package/lib/runtime-install.mjs +11 -3
- package/package.json +1 -1
- package/public-runtime.snapshot.lock.json +9 -5
- package/runtime-catalog.json +24 -8
- /package/lib/host-ipc/{distribution-node-support-contract → distribution-static-room-semantic-contract}/contracts/ugc/creator-source/v1/tool-package.schema.json +0 -0
- /package/lib/host-ipc/{distribution-node-support-contract → distribution-static-room-semantic-contract}/contracts/ugc/registry/v1/conformance/js/capability-resolver.mjs +0 -0
package/README.md
CHANGED
|
@@ -102,6 +102,22 @@ and `M.m.p-alpha.N.P`, with positive, non-zero-prefixed alpha numbers. The full
|
|
|
102
102
|
suffix remains part of every tool identity. Source `publishConfig.tag` validation
|
|
103
103
|
does not publish a package or select the npm dist-tag for an authorized operation.
|
|
104
104
|
|
|
105
|
+
The original catalog-set input accepts a nonempty subset of the known `city`
|
|
106
|
+
and `world` profile keys. Each selected pairing retains its own exact Producer,
|
|
107
|
+
package, content and execution evidence; an unselected profile keeps its actual
|
|
108
|
+
current value. Updating city does not require upgrading or publishing world.
|
|
109
|
+
When selected Producers differ, there is no shared source/version summary.
|
|
110
|
+
After an unknown write, use the original read-only inspect entry; it never
|
|
111
|
+
authorizes retry. A corrupt partial single-profile set cannot establish the
|
|
112
|
+
retained profile and is rejected rather than reconstructed from an older copy.
|
|
113
|
+
|
|
114
|
+
Normal Runtime reports may serve a successor release-tool source only after the
|
|
115
|
+
original pairing Reader verifies their exact target, content, package and
|
|
116
|
+
cleanup bindings. Exact source equality remains the fast path; otherwise the
|
|
117
|
+
existing versioned execution-closure selector and dependency lock must match.
|
|
118
|
+
This does not fabricate a Document shared proof or a new Runtime execution.
|
|
119
|
+
The final source inventory, clean HEAD, catalog CAS, Tag and archive remain exact.
|
|
120
|
+
|
|
105
121
|
For a version-only follow-up with unchanged implementation evidence, `--test-profile release-identity` runs installation, upgrade, metadata and Harness checks and labels the report with that limited coverage; it is not a full regression. Retain the baseline evidence separately. `--parent-version <fixed-parent>` rejects non-increasing versions; before any authorized channel update, supply the actual current npm target with `--channel-version <current-version>` to reject a numeric downgrade. Do not infer live channel state from a local report.
|
|
106
122
|
|
|
107
123
|
Use a clean fixed checkout and the original `npm run verify:npm-package -- --output-directory <new-directory> --producer-content-file <absolute-snapshot-root>/local-content.snapshot.json --environment testing --release-tag v1.5.3 --test-profile release-identity --parent-version 1.5.2` entry for the internal runtime producer. The snapshot must come from the original `chrona build --project ... --output-directory <absolute-snapshot-root>` command; the producer validates it and generates the pinned `runtime-content.json` without hand-copying identity fields or digests. It checks package/lock/CLI versions, immutable tag conflicts, archive installation and schema3 download metadata, and emits `runtime-producer.json` beside the exact internal archive. Only the actual installation platform is declared. An absent tag leaves `tagVerified: false`; this is a candidate, not a release or user download.
|
|
@@ -50,6 +50,46 @@ original source-lock closures; bundling transforms are recorded by that builder,
|
|
|
50
50
|
not guessed from output filenames. Private Room/replication/platform code must
|
|
51
51
|
not be smuggled into a public closure under an allowed name.
|
|
52
52
|
|
|
53
|
+
### Static Content Room source variant
|
|
54
|
+
|
|
55
|
+
Static `schemaVersion: "1.0.0"` has two separate exact source alternatives:
|
|
56
|
+
`{clientsCommitSha,publicNode,publicFlight}` (historical Flight), or
|
|
57
|
+
`{clientsCommitSha,publicNode,contentRoom}` (Content Room). Each source keeps the
|
|
58
|
+
existing exact `{commitSha,sourceHash,lockPath}` reference to a distinct included
|
|
59
|
+
data file. Mixed alternatives, extra `documentAuthority`, missing locks and
|
|
60
|
+
aliases refuse. Content Room is not a renamed Flight export: its real source
|
|
61
|
+
inventory, package/lock and locked dependencies must be packaged and checked by
|
|
62
|
+
the original source Reader and complete-host builder. The manifest does not
|
|
63
|
+
authenticate arbitrary source-lock bytes by itself or grant execution.
|
|
64
|
+
|
|
65
|
+
The static Room variant alone admits the trusted implementation files matching
|
|
66
|
+
`node/content-room-authority/services/game-worker/src/runtime/content/*.js`;
|
|
67
|
+
the final filename uses the existing ASCII filename grammar, without subfolders.
|
|
68
|
+
This does not admit creator `content/`, assets, private paths, Pipeline helpers
|
|
69
|
+
or the separate Document Room namespace. `validRuntimePath`,
|
|
70
|
+
`validateRuntimeFiles` and `encodeRuntimeArchive` accept `{staticRoom:true}`
|
|
71
|
+
for this Writer path; callers select it from their actual source variant.
|
|
72
|
+
`validateRuntimeManifest` derives it from the exact static source shape, and
|
|
73
|
+
`decodeRuntimeArchive` re-encodes with that verified choice. Archive format,
|
|
74
|
+
hashes, targets, protocol 1/2, static policy/entrypoints and exact 1.0 content
|
|
75
|
+
tuple remain unchanged. Document 1.1 still requires its independent
|
|
76
|
+
`publicNode/contentRoom/documentAuthority` sources and original namespace.
|
|
77
|
+
Neither option changes the creator snapshot or implies a playable Runtime.
|
|
78
|
+
|
|
79
|
+
For this exact, validated static Room family only, `assertRuntimeCompatibility`
|
|
80
|
+
matches the declared builderVersion, complete contracts, tool.packageName and
|
|
81
|
+
tool.kitSnapshotHash. Both tool version fields remain required and valid under
|
|
82
|
+
the original tool-version grammar, but packageVersion and kitVersion are source
|
|
83
|
+
provenance rather than execution-interface equality tests. No version range,
|
|
84
|
+
major inference, release-label lookup or per-World exception is introduced.
|
|
85
|
+
The original snapshot/expected identity, content hashes, manifest bytes, release
|
|
86
|
+
package and execution reports retain their full version fields and integrity
|
|
87
|
+
checks; callers must not rewrite them to the selected Runtime's versions.
|
|
88
|
+
Different SDK snapshot, contracts, package name, Builder or target still refuse.
|
|
89
|
+
The historical Flight family and Document 1.1 continue to compare the complete
|
|
90
|
+
tool tuple, including both versions. This rule alone proves neither acceptance
|
|
91
|
+
of an unobserved future Kit nor actual Host execution of any content.
|
|
92
|
+
|
|
53
93
|
`targets` has at most four declarations in canonical-JSON order. Historical
|
|
54
94
|
`{os,arch,nodeVersion:"22.16.0"}` rows retain exact matching, including the Node
|
|
55
95
|
patch and architecture; their bytes and identities are unchanged. They are not
|
|
@@ -11,11 +11,11 @@ const crc32 = bytes => {
|
|
|
11
11
|
return (crc ^ 0xffffffff) >>> 0;
|
|
12
12
|
};
|
|
13
13
|
|
|
14
|
-
export function encodeRuntimeArchive(entries, { document = false } = {}) {
|
|
14
|
+
export function encodeRuntimeArchive(entries, { document = false, staticRoom = false } = {}) {
|
|
15
15
|
if (!Array.isArray(entries) || entries.length > RUNTIME_LIMITS.files) fail('INVALID_RUNTIME_FILES');
|
|
16
16
|
const files = entries.map(e => ({ path: e.path, role: e.role, bytes: e.bytes?.byteLength,
|
|
17
17
|
sha256: e.bytes instanceof Uint8Array ? runtimeHash(e.bytes) : '' }));
|
|
18
|
-
validateRuntimeFiles(files, { document });
|
|
18
|
+
validateRuntimeFiles(files, { document, staticRoom });
|
|
19
19
|
const local = [], central = []; let offset = 0, centralBytes = 0;
|
|
20
20
|
for (const entry of entries) {
|
|
21
21
|
const name = Buffer.from(entry.path), data = Buffer.from(entry.bytes), crc = crc32(data);
|
|
@@ -47,6 +47,7 @@ export function decodeRuntimeArchive(bytes, manifest) {
|
|
|
47
47
|
if (runtimeHash(data) !== file.sha256) fail('RUNTIME_ARCHIVE_HASH_MISMATCH');
|
|
48
48
|
entries.push({ path: file.path, role: file.role, bytes: data }); offset = end;
|
|
49
49
|
}
|
|
50
|
-
if (!encodeRuntimeArchive(entries, { document: manifest.schemaVersion === '1.1.0'
|
|
50
|
+
if (!encodeRuntimeArchive(entries, { document: manifest.schemaVersion === '1.1.0',
|
|
51
|
+
staticRoom: manifest.schemaVersion === '1.0.0' && Object.hasOwn(manifest.source, 'contentRoom') }).equals(archive)) fail('INVALID_RUNTIME_ARCHIVE');
|
|
51
52
|
return entries;
|
|
52
53
|
}
|
|
@@ -14,9 +14,10 @@ const toolVersion = v => typeof v === 'string' && /^(0|[1-9][0-9]*)\.(0|[1-9][0-
|
|
|
14
14
|
const bounded = (v, min, max) => Number.isSafeInteger(v) && v >= min && v <= max;
|
|
15
15
|
const roles = ['node', 'browser', 'sandbox', 'wasm', 'data', 'license'];
|
|
16
16
|
|
|
17
|
-
export function validRuntimePath(v, { document = false } = {}) {
|
|
18
|
-
const roomImplementation =
|
|
19
|
-
|
|
17
|
+
export function validRuntimePath(v, { document = false, staticRoom = false } = {}) {
|
|
18
|
+
const roomImplementation = typeof v === 'string' && (document
|
|
19
|
+
? /^node\/content-room-document-authority\/services\/game-worker\/src\/runtime\/content\/[A-Za-z0-9_-][A-Za-z0-9_.-]*\.js$/.test(v)
|
|
20
|
+
: staticRoom && /^node\/content-room-authority\/services\/game-worker\/src\/runtime\/content\/[A-Za-z0-9_-][A-Za-z0-9_.-]*\.js$/.test(v));
|
|
20
21
|
const localExecutionImplementation = document && typeof v === 'string'
|
|
21
22
|
&& /^node\/document-local-execution\/services\/ugc-pipeline\/src\/(?:document-local-execution|private-state-model|private-event-model|private-ecs-model|registry-release)\.mjs$/.test(v);
|
|
22
23
|
return typeof v === 'string' && v.length <= 512 && /^[A-Za-z0-9_@-][A-Za-z0-9_@.-]*(?:\/[A-Za-z0-9_@-][A-Za-z0-9_@.-]*)*$/.test(v)
|
|
@@ -27,12 +28,12 @@ export function validRuntimePath(v, { document = false } = {}) {
|
|
|
27
28
|
&& !/\.(?:pem|key|p12|pfx|glb|gltf)$/i.test(v) && !['runtime.zip', 'runtime-manifest.json'].includes(v.toLowerCase());
|
|
28
29
|
}
|
|
29
30
|
|
|
30
|
-
export function validateRuntimeFiles(files, { document = false } = {}) {
|
|
31
|
+
export function validateRuntimeFiles(files, { document = false, staticRoom = false } = {}) {
|
|
31
32
|
if (!Array.isArray(files) || !files.length || files.length > RUNTIME_LIMITS.files) fail('INVALID_RUNTIME_FILES');
|
|
32
33
|
let previous = '', total = 0;
|
|
33
34
|
const folded = new Set(), directories = new Set();
|
|
34
35
|
for (const f of files) {
|
|
35
|
-
if (!exact(f, ['path', 'bytes', 'sha256', 'role']) || !validRuntimePath(f.path, { document }) || f.path <= previous
|
|
36
|
+
if (!exact(f, ['path', 'bytes', 'sha256', 'role']) || !validRuntimePath(f.path, { document, staticRoom }) || f.path <= previous
|
|
36
37
|
|| !digest(f.sha256) || !bounded(f.bytes, 0, RUNTIME_LIMITS.fileBytes) || !roles.includes(f.role)) fail('INVALID_RUNTIME_FILES');
|
|
37
38
|
const parts = f.path.toLowerCase().split('/');
|
|
38
39
|
if (folded.has(parts.join('/')) || directories.has(parts.join('/')) || parts.some((_, i) => folded.has(parts.slice(0, i).join('/')))) fail('INVALID_RUNTIME_FILES');
|
|
@@ -101,12 +102,16 @@ export function validateRuntimeManifest(v) {
|
|
|
101
102
|
if (!exact(v, ['schemaVersion', 'kind', 'apiVersion', 'runtimeId', 'runtimeHash', 'executionTier', 'source', 'targets', 'compatibility', 'entrypoints', 'files', 'archive'])
|
|
102
103
|
|| !['1.0.0', '1.1.0'].includes(v.schemaVersion) || v.kind !== 'public-local-runtime' || v.apiVersion !== '1.0.0'
|
|
103
104
|
|| v.executionTier !== 'public-untrusted' || !/^runtime_[a-f0-9]{64}$/.test(v.runtimeId ?? '') || !digest(v.runtimeHash)) fail('INVALID_RUNTIME_MANIFEST');
|
|
104
|
-
validateRuntimeFiles(v.files, { document: v.schemaVersion === '1.1.0' });
|
|
105
105
|
const document = v.schemaVersion === '1.1.0';
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
const
|
|
106
|
+
// Static Room is a distinct source closure, not Document or historical Flight.
|
|
107
|
+
// The exact source shape selects only its fixed implementation namespace.
|
|
108
|
+
const staticRoom = !document && exact(v.source, ['clientsCommitSha', 'publicNode', 'contentRoom']);
|
|
109
|
+
const sourceKeys = document ? ['publicNode', 'contentRoom', 'documentAuthority']
|
|
110
|
+
: staticRoom ? ['publicNode', 'contentRoom'] : ['publicNode', 'publicFlight'];
|
|
109
111
|
if (!exact(v.source, ['clientsCommitSha', ...sourceKeys]) || !commit(v.source.clientsCommitSha)) fail('INVALID_RUNTIME_SOURCE');
|
|
112
|
+
validateRuntimeFiles(v.files, { document, staticRoom });
|
|
113
|
+
const files = new Map(v.files.map(f => [f.path, f]));
|
|
114
|
+
const reference = (p, role) => validRuntimePath(p, { document, staticRoom }) && files.get(p)?.role === role;
|
|
110
115
|
for (const key of sourceKeys) {
|
|
111
116
|
const source = v.source[key];
|
|
112
117
|
if (!exact(source, ['commitSha', 'sourceHash', 'lockPath']) || !commit(source.commitSha) || !digest(source.sourceHash)
|
|
@@ -184,7 +189,13 @@ export function assertRuntimeTargetCompatibility(manifest, { target = { os: proc
|
|
|
184
189
|
export function assertRuntimeCompatibility(manifest, { target, expected } = {}) {
|
|
185
190
|
assertRuntimeTargetCompatibility(manifest, { target });
|
|
186
191
|
const row = { builderVersion: expected?.builderVersion, tool: expected?.tool, contracts: expected?.contracts };
|
|
187
|
-
|
|
192
|
+
const staticRoom = manifest.schemaVersion === '1.0.0' && exact(manifest.source, ['clientsCommitSha', 'publicNode', 'contentRoom']);
|
|
193
|
+
// Tool versions retain snapshot/report provenance. Only this validated static
|
|
194
|
+
// Room family matches the actual Builder/contracts/SDK interface instead.
|
|
195
|
+
if (!validContentRow(row, manifest.schemaVersion === '1.1.0') || !manifest.compatibility.content.some(r => staticRoom
|
|
196
|
+
? r.builderVersion === row.builderVersion && canonicalJson(r.contracts) === canonicalJson(row.contracts)
|
|
197
|
+
&& r.tool.packageName === row.tool.packageName && r.tool.kitSnapshotHash === row.tool.kitSnapshotHash
|
|
198
|
+
: canonicalJson(r) === canonicalJson(row))) fail('RUNTIME_CONTENT_INCOMPATIBLE');
|
|
188
199
|
return true;
|
|
189
200
|
}
|
|
190
201
|
|
|
@@ -82,6 +82,26 @@
|
|
|
82
82
|
"$ref": "#/$defs/source"
|
|
83
83
|
}
|
|
84
84
|
}
|
|
85
|
+
},
|
|
86
|
+
{
|
|
87
|
+
"type": "object",
|
|
88
|
+
"additionalProperties": false,
|
|
89
|
+
"required": [
|
|
90
|
+
"clientsCommitSha",
|
|
91
|
+
"publicNode",
|
|
92
|
+
"contentRoom"
|
|
93
|
+
],
|
|
94
|
+
"properties": {
|
|
95
|
+
"clientsCommitSha": {
|
|
96
|
+
"$ref": "#/$defs/commit"
|
|
97
|
+
},
|
|
98
|
+
"publicNode": {
|
|
99
|
+
"$ref": "#/$defs/source"
|
|
100
|
+
},
|
|
101
|
+
"contentRoom": {
|
|
102
|
+
"$ref": "#/$defs/source"
|
|
103
|
+
}
|
|
104
|
+
}
|
|
85
105
|
}
|
|
86
106
|
]
|
|
87
107
|
},
|
|
@@ -649,24 +669,48 @@
|
|
|
649
669
|
"then": {
|
|
650
670
|
"properties": {
|
|
651
671
|
"source": {
|
|
652
|
-
"
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
"
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
672
|
+
"oneOf": [
|
|
673
|
+
{
|
|
674
|
+
"type": "object",
|
|
675
|
+
"additionalProperties": false,
|
|
676
|
+
"required": [
|
|
677
|
+
"clientsCommitSha",
|
|
678
|
+
"publicNode",
|
|
679
|
+
"publicFlight"
|
|
680
|
+
],
|
|
681
|
+
"properties": {
|
|
682
|
+
"clientsCommitSha": {
|
|
683
|
+
"$ref": "#/$defs/commit"
|
|
684
|
+
},
|
|
685
|
+
"publicNode": {
|
|
686
|
+
"$ref": "#/$defs/source"
|
|
687
|
+
},
|
|
688
|
+
"publicFlight": {
|
|
689
|
+
"$ref": "#/$defs/source"
|
|
690
|
+
}
|
|
691
|
+
}
|
|
665
692
|
},
|
|
666
|
-
|
|
667
|
-
"
|
|
693
|
+
{
|
|
694
|
+
"type": "object",
|
|
695
|
+
"additionalProperties": false,
|
|
696
|
+
"required": [
|
|
697
|
+
"clientsCommitSha",
|
|
698
|
+
"publicNode",
|
|
699
|
+
"contentRoom"
|
|
700
|
+
],
|
|
701
|
+
"properties": {
|
|
702
|
+
"clientsCommitSha": {
|
|
703
|
+
"$ref": "#/$defs/commit"
|
|
704
|
+
},
|
|
705
|
+
"publicNode": {
|
|
706
|
+
"$ref": "#/$defs/source"
|
|
707
|
+
},
|
|
708
|
+
"contentRoom": {
|
|
709
|
+
"$ref": "#/$defs/source"
|
|
710
|
+
}
|
|
711
|
+
}
|
|
668
712
|
}
|
|
669
|
-
|
|
713
|
+
]
|
|
670
714
|
},
|
|
671
715
|
"compatibility": {
|
|
672
716
|
"type": "object",
|
|
@@ -0,0 +1,225 @@
|
|
|
1
|
+
import test from 'node:test';
|
|
2
|
+
import assert from 'node:assert/strict';
|
|
3
|
+
import { readFile, mkdir, writeFile } from 'node:fs/promises';
|
|
4
|
+
import { resolve, join } from 'node:path';
|
|
5
|
+
import { pathToFileURL } from 'node:url';
|
|
6
|
+
import { createFormatFixture } from './format-fixture.mjs';
|
|
7
|
+
import { encodeRuntimeArchive, decodeRuntimeArchive } from './archive.mjs';
|
|
8
|
+
import { runtimeCanonical, runtimeHash, runtimeIdentity, computeRuntimeHash, validateRuntimeManifest,
|
|
9
|
+
verifyRuntimeManifest, verifyRuntimePair, assertRuntimeCompatibility, validRuntimePath } from './manifest.mjs';
|
|
10
|
+
|
|
11
|
+
const prefix = 'node/content-room-authority/';
|
|
12
|
+
const implementation = `${prefix}services/game-worker/src/runtime/content/content-room-source.js`;
|
|
13
|
+
const sort = entries => entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
|
|
14
|
+
function assemble(entries, roomSource) {
|
|
15
|
+
const f = createFormatFixture(), manifest = structuredClone(f.manifest);
|
|
16
|
+
delete manifest.source.publicFlight;
|
|
17
|
+
manifest.source.contentRoom = roomSource;
|
|
18
|
+
entries = sort([...f.entries, ...entries]);
|
|
19
|
+
const archive = encodeRuntimeArchive(entries, { staticRoom: true });
|
|
20
|
+
manifest.files = entries.map(e => ({ path: e.path, role: e.role, bytes: e.bytes.length, sha256: runtimeHash(e.bytes) }));
|
|
21
|
+
manifest.archive = { ...manifest.archive, bytes: archive.length, sha256: runtimeHash(archive) };
|
|
22
|
+
manifest.runtimeHash = computeRuntimeHash(manifest); manifest.runtimeId = runtimeIdentity(manifest);
|
|
23
|
+
const bytes = Buffer.from(`${runtimeCanonical(manifest)}\n`), manifestHash = runtimeHash(bytes);
|
|
24
|
+
const lock = { ...f.lock, runtimeId: manifest.runtimeId, runtimeHash: manifest.runtimeHash,
|
|
25
|
+
manifest: { ...f.lock.manifest, bytes: bytes.length, sha256: manifestHash },
|
|
26
|
+
archive: { ...f.lock.archive, bytes: archive.length, sha256: runtimeHash(archive) } };
|
|
27
|
+
return { manifest, archive, entries, bytes, manifestHash, lock, target: f.target, expected: f.expected };
|
|
28
|
+
}
|
|
29
|
+
function fixture() {
|
|
30
|
+
return assemble([
|
|
31
|
+
{ path: implementation, role: 'node', bytes: Buffer.from('STATIC ROOM FORMAT FIXTURE ONLY\n') },
|
|
32
|
+
{ path: `${prefix}source-lock.json`, role: 'data', bytes: Buffer.from('SOURCE LOCK FORMAT FIXTURE ONLY\n') }
|
|
33
|
+
], { commitSha: 'e'.repeat(40), sourceHash: runtimeHash('room-format-fixture'), lockPath: `${prefix}source-lock.json` });
|
|
34
|
+
}
|
|
35
|
+
const rehash = m => { m.runtimeHash = computeRuntimeHash(m); m.runtimeId = runtimeIdentity(m); };
|
|
36
|
+
|
|
37
|
+
test('static Room archive Writer and Reader bind independent Room without Document or Flight claims', () => {
|
|
38
|
+
const f = fixture(), m = verifyRuntimeManifest(f.bytes, f.manifestHash);
|
|
39
|
+
assert.equal(m.schemaVersion, '1.0.0');
|
|
40
|
+
assert.deepEqual(Object.keys(m.source).sort(), ['clientsCommitSha', 'contentRoom', 'publicNode']);
|
|
41
|
+
assert.equal(m.source.documentAuthority, undefined); assert.equal(m.source.publicFlight, undefined);
|
|
42
|
+
assert.deepEqual(decodeRuntimeArchive(f.archive, m), f.entries);
|
|
43
|
+
assert.equal(verifyRuntimePair(m, f.lock, f.expected, { target: f.target }).ready, false);
|
|
44
|
+
const wrong = structuredClone(f.expected); wrong.contracts.contractSetHashes.worldScene = runtimeHash('wrong-content');
|
|
45
|
+
assert.throws(() => assertRuntimeCompatibility(m, { target: f.target, expected: wrong }), { code: 'RUNTIME_CONTENT_INCOMPATIBLE' });
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
test('static Room admits its fixed implementation namespace without opening author or Document paths', () => {
|
|
49
|
+
assert.equal(validRuntimePath(implementation), false);
|
|
50
|
+
assert.equal(validRuntimePath(implementation, { staticRoom: true }), true);
|
|
51
|
+
assert.equal(validRuntimePath(implementation, { document: true }), false);
|
|
52
|
+
for (const path of ['content/shared/main.js', `${prefix}content/main.js`,
|
|
53
|
+
`${prefix}services/game-worker/src/runtime/content/author.glb`,
|
|
54
|
+
`${prefix}services/game-worker/src/runtime/content/private/main.js`,
|
|
55
|
+
`${prefix}services/ugc-pipeline/src/local-content.mjs`,
|
|
56
|
+
'node/content-room-document-authority/services/game-worker/src/runtime/content/content-room-source.js',
|
|
57
|
+
'node/other/services/game-worker/src/runtime/content/content-room-source.js'])
|
|
58
|
+
assert.equal(validRuntimePath(path, { staticRoom: true }), false, path);
|
|
59
|
+
assert.throws(() => encodeRuntimeArchive(fixture().entries), { code: 'INVALID_RUNTIME_FILES' });
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
test('static Room source variants, lock references, inventory and archive bytes remain exact', () => {
|
|
63
|
+
for (const [mutate, code] of [
|
|
64
|
+
[m => { m.source.publicFlight = m.source.contentRoom; }, 'INVALID_RUNTIME_SOURCE'],
|
|
65
|
+
[m => { m.source.documentAuthority = m.source.contentRoom; }, 'INVALID_RUNTIME_SOURCE'],
|
|
66
|
+
[m => { delete m.source.contentRoom; }, 'INVALID_RUNTIME_SOURCE'],
|
|
67
|
+
[m => { m.source.contentRoom.lockPath = m.source.publicNode.lockPath; }, 'INVALID_RUNTIME_SOURCE'],
|
|
68
|
+
[m => { m.source.contentRoom.lockPath = 'data/missing.json'; }, 'INVALID_RUNTIME_SOURCE'],
|
|
69
|
+
[m => { m.source.contentRoom.sourceHash = 'unknown'; }, 'INVALID_RUNTIME_SOURCE'],
|
|
70
|
+
[m => { m.schemaVersion = '1.1.0'; }, 'INVALID_RUNTIME_SOURCE'],
|
|
71
|
+
[m => { m.compatibility.protocol.schemaRevision = 3; }, 'INVALID_RUNTIME_COMPATIBILITY'],
|
|
72
|
+
[m => { m.compatibility.content[0].builderVersion = 'local-content@1.1.0'; }, 'INVALID_RUNTIME_COMPATIBILITY']
|
|
73
|
+
]) {
|
|
74
|
+
const { manifest } = fixture(); mutate(manifest); rehash(manifest);
|
|
75
|
+
assert.throws(() => validateRuntimeManifest(manifest), { code });
|
|
76
|
+
}
|
|
77
|
+
const f = fixture(), wrong = Buffer.from(f.archive); wrong[50] ^= 1;
|
|
78
|
+
assert.throws(() => decodeRuntimeArchive(wrong, f.manifest), { code: 'RUNTIME_ARCHIVE_HASH_MISMATCH' });
|
|
79
|
+
const altered = structuredClone(f.manifest); altered.files.find(x => x.path === implementation).sha256 = runtimeHash('drift');
|
|
80
|
+
assert.throws(() => validateRuntimeManifest(altered), { code: 'RUNTIME_PACKAGE_IDENTITY_MISMATCH' });
|
|
81
|
+
rehash(altered);
|
|
82
|
+
assert.throws(() => decodeRuntimeArchive(f.archive, altered), { code: 'RUNTIME_ARCHIVE_HASH_MISMATCH' });
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
test('schema preserves two exact static source alternatives and the separate Document source', async () => {
|
|
86
|
+
const s = JSON.parse(await readFile(new URL('./runtime-manifest.schema.json', import.meta.url)));
|
|
87
|
+
const variants = s.allOf[0].then.properties.source.oneOf;
|
|
88
|
+
assert.equal(variants.length, 2);
|
|
89
|
+
assert.deepEqual(variants.map(x => x.required.slice().sort()), [
|
|
90
|
+
['clientsCommitSha', 'publicFlight', 'publicNode'], ['clientsCommitSha', 'contentRoom', 'publicNode']
|
|
91
|
+
]);
|
|
92
|
+
for (const v of variants) assert.equal(v.additionalProperties, false);
|
|
93
|
+
assert.deepEqual(s.properties.source.oneOf.map(x => x.required.slice().sort()), [
|
|
94
|
+
variants[0].required.slice().sort(), ['clientsCommitSha', 'contentRoom', 'documentAuthority', 'publicNode'],
|
|
95
|
+
variants[1].required.slice().sort()
|
|
96
|
+
]);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
test('only static Room compatibility treats valid tool versions as provenance, preserving interface identity', () => {
|
|
100
|
+
const f = fixture();
|
|
101
|
+
for (const field of ['packageVersion', 'kitVersion']) {
|
|
102
|
+
for (const version of ['1.5.9', '1.5.10', '1.5.11']) {
|
|
103
|
+
// Version shape vectors only; 1.5.11 here is not a real Kit reference.
|
|
104
|
+
const expected = structuredClone(f.expected); expected.tool[field] = version;
|
|
105
|
+
assert.equal(verifyRuntimePair(f.manifest, f.lock, expected, { target: f.target }).ready, false);
|
|
106
|
+
assert.equal(f.expected.tool[field], '0.2.5');
|
|
107
|
+
}
|
|
108
|
+
for (const version of [undefined, null, '', '01.5.9', '1.5', '1.5.9-beta.1']) {
|
|
109
|
+
const expected = structuredClone(f.expected); expected.tool[field] = version;
|
|
110
|
+
assert.throws(() => assertRuntimeCompatibility(f.manifest, { target: f.target, expected }), { code: 'RUNTIME_CONTENT_INCOMPATIBLE' });
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
for (const mutate of [
|
|
114
|
+
row => { row.builderVersion = 'local-content@1.1.0'; },
|
|
115
|
+
row => { row.tool.packageName = '@chrona-city/ugc-kit'; },
|
|
116
|
+
row => { row.tool.kitSnapshotHash = runtimeHash('another-sdk'); },
|
|
117
|
+
row => { row.tool.extra = true; },
|
|
118
|
+
row => { row.contracts.registryVersion = '1.1.11'; },
|
|
119
|
+
row => { row.contracts.registryHash = runtimeHash('another-registry'); },
|
|
120
|
+
row => { row.contracts.resolutionPolicyHash = runtimeHash('another-policy'); },
|
|
121
|
+
row => { row.contracts.contractSetHashes.localContent = runtimeHash('another-builder'); },
|
|
122
|
+
row => { row.contracts.contractSetHashes.worldScene = runtimeHash('another-world'); }
|
|
123
|
+
]) {
|
|
124
|
+
const expected = structuredClone(f.expected); mutate(expected);
|
|
125
|
+
assert.throws(() => assertRuntimeCompatibility(f.manifest, { target: f.target, expected }), { code: 'RUNTIME_CONTENT_INCOMPATIBLE' });
|
|
126
|
+
}
|
|
127
|
+
assert.throws(() => assertRuntimeCompatibility(f.manifest, { target: { ...f.target, nodeVersion: '24.1.0' }, expected: f.expected }),
|
|
128
|
+
{ code: 'RUNTIME_TARGET_UNSUPPORTED' });
|
|
129
|
+
const malformed = structuredClone(f.manifest); malformed.compatibility.content[0].tool.kitVersion = 'unknown'; rehash(malformed);
|
|
130
|
+
assert.throws(() => assertRuntimeCompatibility(malformed, f), { code: 'INVALID_RUNTIME_COMPATIBILITY' });
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
test('Flight and Document preserve complete version matching and cannot select the static Room rule', () => {
|
|
134
|
+
const legacy = createFormatFixture();
|
|
135
|
+
for (const key of ['packageVersion', 'kitVersion']) {
|
|
136
|
+
const expected = structuredClone(legacy.expected); expected.tool[key] = '1.5.11';
|
|
137
|
+
assert.throws(() => assertRuntimeCompatibility(legacy.manifest, { target: legacy.target, expected }), { code: 'RUNTIME_CONTENT_INCOMPATIBLE' });
|
|
138
|
+
}
|
|
139
|
+
const document = fixture(); delete document.manifest.source.contentRoom;
|
|
140
|
+
document.manifest.source.contentRoom = { commitSha: 'e'.repeat(40), sourceHash: runtimeHash('doc-room'), lockPath: 'data/flight.json' };
|
|
141
|
+
document.manifest.source.documentAuthority = { commitSha: 'f'.repeat(40), sourceHash: runtimeHash('doc-authority'), lockPath: 'data/style.json' };
|
|
142
|
+
document.manifest.schemaVersion = '1.1.0';
|
|
143
|
+
document.manifest.files = document.manifest.files.filter(row => row.path !== implementation);
|
|
144
|
+
document.manifest.files.push({ path: 'sandbox/document-view.html', role: 'sandbox', bytes: 0, sha256: runtimeHash('') });
|
|
145
|
+
document.manifest.files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
|
|
146
|
+
document.manifest.compatibility.content[0].builderVersion = 'local-content@1.1.0';
|
|
147
|
+
document.manifest.compatibility.content[0].contracts.contractSetHashes.documentPresentation = runtimeHash('doc');
|
|
148
|
+
document.manifest.compatibility.policyFiles = { documentPresentation: 'data/world.json' };
|
|
149
|
+
document.manifest.entrypoints.sandbox = 'sandbox/document-view.html';
|
|
150
|
+
document.manifest.archive.bytes = 22 + document.manifest.files.reduce((n, f) => n + f.bytes + 76 + 2 * Buffer.byteLength(f.path), 0);
|
|
151
|
+
rehash(document.manifest); validateRuntimeManifest(document.manifest);
|
|
152
|
+
for (const key of ['packageVersion', 'kitVersion']) {
|
|
153
|
+
const expected = structuredClone(document.manifest.compatibility.content[0]); expected.tool[key] = '1.5.11';
|
|
154
|
+
assert.throws(() => assertRuntimeCompatibility(document.manifest, { target: document.target, expected }), { code: 'RUNTIME_CONTENT_INCOMPATIBLE' });
|
|
155
|
+
}
|
|
156
|
+
});
|
|
157
|
+
|
|
158
|
+
test('unchanged real 159 and 1510 Builder outputs match one static Room row through the original full Reader', {
|
|
159
|
+
skip: !process.env.CHRONA_STATIC_SEMANTIC_INPUTS || !process.env.CHRONA_STATIC_SEMANTIC_READER
|
|
160
|
+
}, async () => {
|
|
161
|
+
const reader = await import(pathToFileURL(resolve(process.env.CHRONA_STATIC_SEMANTIC_READER)));
|
|
162
|
+
const rows = [], pins = [];
|
|
163
|
+
for (const file of JSON.parse(process.env.CHRONA_STATIC_SEMANTIC_INPUTS)) {
|
|
164
|
+
const original = await readFile(file), content = JSON.parse(original);
|
|
165
|
+
const input = await reader.openLocalContentInput(content, { runtimeReader: true });
|
|
166
|
+
try {
|
|
167
|
+
assert.equal(input.snapshot.schemaVersion, '1.0.0');
|
|
168
|
+
assert.deepEqual(input.validation.identity, content.expected);
|
|
169
|
+
let bytes = 0;
|
|
170
|
+
for (const item of input.snapshot.files) bytes += (await input.files.read(item.path)).length;
|
|
171
|
+
rows.push(structuredClone(input.validation.identity));
|
|
172
|
+
pins.push({ inputHash: runtimeHash(original), expected: input.validation.identity, files: input.snapshot.files.length, bytes });
|
|
173
|
+
} finally { await input.close(); }
|
|
174
|
+
assert.deepEqual(await readFile(file), original);
|
|
175
|
+
}
|
|
176
|
+
assert.equal(rows.length, 2);
|
|
177
|
+
assert.deepEqual(rows.map(row => row.tool.packageVersion), ['1.5.9', '1.5.10']);
|
|
178
|
+
assert.deepEqual(rows[0].contracts, rows[1].contracts);
|
|
179
|
+
assert.equal(rows[0].tool.kitSnapshotHash, rows[1].tool.kitSnapshotHash);
|
|
180
|
+
const f = fixture();
|
|
181
|
+
f.manifest.compatibility.content = [{ builderVersion: rows[1].builderVersion, tool: rows[1].tool, contracts: rows[1].contracts }];
|
|
182
|
+
rehash(f.manifest);
|
|
183
|
+
const manifestBytes = Buffer.from(`${runtimeCanonical(f.manifest)}\n`);
|
|
184
|
+
f.lock.runtimeId = f.manifest.runtimeId; f.lock.runtimeHash = f.manifest.runtimeHash;
|
|
185
|
+
f.lock.manifest = { ...f.lock.manifest, bytes: manifestBytes.length, sha256: runtimeHash(manifestBytes) };
|
|
186
|
+
const manifest = verifyRuntimeManifest(manifestBytes, runtimeHash(manifestBytes));
|
|
187
|
+
for (const expected of rows) assert.equal(verifyRuntimePair(manifest, f.lock, expected, { target: f.target }).ready, false);
|
|
188
|
+
if (process.env.CHRONA_STATIC_SEMANTIC_OUTPUT) await writeFile(process.env.CHRONA_STATIC_SEMANTIC_OUTPUT,
|
|
189
|
+
`${JSON.stringify({ fixtureOnly: true, executable: false, actual1511ReferenceVerified: false,
|
|
190
|
+
inputs: pins, manifestBytesBase64: manifestBytes.toString('base64'), manifestHash: runtimeHash(manifestBytes),
|
|
191
|
+
lock: f.lock, target: f.target, hostVerified: false }, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
test('original 70-source Room Reader output survives real archive Writer and independent decode', {
|
|
195
|
+
skip: !process.env.CHRONA_STATIC_ROOM_DIRECTORY || !process.env.CHRONA_STATIC_ROOM_READER
|
|
196
|
+
}, async () => {
|
|
197
|
+
// Only the original fixed Reader can supply this source. The outer host/WASM
|
|
198
|
+
// fixture remains non-executable; no installed Runtime or Guest is claimed.
|
|
199
|
+
const directory = resolve(process.env.CHRONA_STATIC_ROOM_DIRECTORY);
|
|
200
|
+
const reader = await import(pathToFileURL(resolve(process.env.CHRONA_STATIC_ROOM_READER)));
|
|
201
|
+
const { lock, files } = await reader.readContentRoomAuthority(directory);
|
|
202
|
+
assert.equal(lock.manifest.files.length, 70);
|
|
203
|
+
const entries = [...files].map(([path, bytes]) => ({ path: `${prefix}${path}`, bytes,
|
|
204
|
+
role: /\.(?:js|mjs|cjs)$/.test(path) ? 'node' : 'data' }));
|
|
205
|
+
const lockBytes = await readFile(join(directory, 'source-lock.json'));
|
|
206
|
+
entries.push({ path: `${prefix}source-lock.json`, bytes: lockBytes, role: 'data' });
|
|
207
|
+
const f = assemble(entries, { commitSha: lock.sourceCommit, sourceHash: lock.manifest.sourceHash,
|
|
208
|
+
lockPath: `${prefix}source-lock.json` });
|
|
209
|
+
const m = verifyRuntimeManifest(f.bytes, f.manifestHash);
|
|
210
|
+
const decoded = new Map(decodeRuntimeArchive(f.archive, m).map(x => [x.path, x.bytes]));
|
|
211
|
+
for (const row of lock.manifest.files) assert.equal(runtimeHash(decoded.get(`${prefix}${row.path}`)), `sha256:${row.sha256}`);
|
|
212
|
+
assert.deepEqual(decoded.get(`${prefix}source-lock.json`), lockBytes);
|
|
213
|
+
assert.equal(verifyRuntimePair(m, f.lock, f.expected, { target: f.target }).ready, false);
|
|
214
|
+
if (process.env.CHRONA_STATIC_ROOM_OUTPUT) {
|
|
215
|
+
const output = resolve(process.env.CHRONA_STATIC_ROOM_OUTPUT);
|
|
216
|
+
await mkdir(output, { recursive: true, mode: 0o700 });
|
|
217
|
+
for (const [name, bytes] of [['runtime-manifest.json', f.bytes], ['runtime.zip', f.archive],
|
|
218
|
+
['runtime-lock.json', Buffer.from(`${JSON.stringify(f.lock, null, 2)}\n`)],
|
|
219
|
+
['result.json', Buffer.from(`${JSON.stringify({ fixtureOnly: true, executable: false,
|
|
220
|
+
originalRoomFiles: lock.manifest.files.length, roomCommit: lock.sourceCommit, roomSourceHash: lock.manifest.sourceHash,
|
|
221
|
+
roomLockHash: runtimeHash(lockBytes), manifestHash: f.manifestHash, archiveHash: runtimeHash(f.archive),
|
|
222
|
+
files: m.files.length, archiveBytes: f.archive.length, ready: false }, null, 2)}\n`)]])
|
|
223
|
+
await writeFile(join(output, name), bytes, { flag: 'wx', mode: 0o600 });
|
|
224
|
+
}
|
|
225
|
+
});
|
|
@@ -120,9 +120,12 @@ Read `uploadPreflight`: source upload needs `projects:read`, `source:read` and
|
|
|
120
120
|
`submissions:write`. A contribution uses the existing separate
|
|
121
121
|
`contributions:write` scope. Missing scopes require an explicit new authorization
|
|
122
122
|
in a separate private session directory; preserve the old session. Do not edit
|
|
123
|
-
saved bindings, revoke it automatically or copy browser credentials.
|
|
124
|
-
|
|
125
|
-
|
|
123
|
+
saved bindings, revoke it automatically or copy browser credentials. Platform
|
|
124
|
+
expiry timestamps are not compared with the device clock; the platform still
|
|
125
|
+
enforces expiry and revocation. An uncertain or unusable saved authorization
|
|
126
|
+
requires explicit continuation (`CREATOR_SESSION_RENEWAL_REQUIRED`); platform
|
|
127
|
+
rejections retain their specific error. Preserve the record, and do not retry an
|
|
128
|
+
unknown token exchange automatically. Authorization
|
|
126
129
|
does not grant material entitlement, candidate acceptance or publication rights.
|
|
127
130
|
|
|
128
131
|
## Create and edit the selected work
|
package/docs/npm-creator.md
CHANGED
|
@@ -220,7 +220,7 @@ Static validate never imports creator JavaScript. Repair its structured errors a
|
|
|
220
220
|
|
|
221
221
|
### Upload authorization preflight
|
|
222
222
|
|
|
223
|
-
The upload operation needs `source:read` to inspect/resume blobs, `submissions:write` to submit and `projects:read` for live platform preflight. `projects:create` replaces none of these scopes. The
|
|
223
|
+
The upload operation needs `source:read` to inspect/resume blobs, `submissions:write` to submit and `projects:read` for live platform preflight. `projects:create` replaces none of these scopes. The Kit checks the saved credential structure, fixed Origin, selected project scope and upload scopes before scanning the content tree. Expiry timestamps belong to the platform clock: the Kit preserves them but does not reject authorization, exchange, upload or snapshot reads by comparing them with the device clock. The platform enforces actual expiry, revocation, current membership and eligibility on each operation. Missing scopes return `CREATOR_SESSION_SCOPE_REQUIRED` with `requiredScopes` and `missingScopes`; a different project grant returns `CREATOR_SESSION_PROJECT_MISMATCH`. Local checks grant nothing and never extend an authorization.
|
|
224
224
|
|
|
225
225
|
Read `uploadPreflight` in `auth-status` or MCP authorization results, including a reused `authorized` session. `scope-ready` means only that the local session contains the upload scopes; it is not permission to use every project or proof of publication. For `missing-scopes`, preserve the old session and explicitly use `login` with a new private session directory, the same trusted platform Origin, the intended `--project-id` and `--scopes source:read,submissions:write,projects:read`; complete normal browser approval and `login-complete`, then submit through that new session. Add other scopes only for intended operations. A project-bound grant cannot create new projects. Do not edit the existing session or automatically log it out. Repointing an existing MCP registration requires explicit configuration resolution; the tool never silently replaces it. Earlier fixed archives do not acquire this preflight without a separately installed candidate.
|
|
226
226
|
|
package/docs/runtime-download.md
CHANGED
|
@@ -16,6 +16,15 @@ current digest remains in the complete Producer evidence; the Clients Writer
|
|
|
16
16
|
also verifies this leaf in the fixed current checkout. Compiler, SDK, contracts,
|
|
17
17
|
policies, installed toolchain and runtime/host dependencies remain protected.
|
|
18
18
|
|
|
19
|
+
Scoped patch reuse uses the existing versioned companion execution selector.
|
|
20
|
+
Both actual profile lock bodies are bound to their own Producer evidence; only
|
|
21
|
+
`version` and `packages[""].version` are excluded from dependency comparison.
|
|
22
|
+
All dependency/SRI/resolved fields remain exact. The reuse output retains
|
|
23
|
+
`current-profile-package-lock.json` and `baseline-profile-package-lock.json`;
|
|
24
|
+
portable material carries these two explicit roles without new delivery fields
|
|
25
|
+
or host-path fallback. The report target remains the original observed machine,
|
|
26
|
+
not the manifest's support declarations.
|
|
27
|
+
|
|
19
28
|
Catalog writing binds three separate sources: the immutable internal Producer,
|
|
20
29
|
the current catalog writer, and the later final package commit. Only a verified
|
|
21
30
|
reuse delivery can use a successor writer with the same protected execution
|
|
@@ -40,6 +49,17 @@ token, arbitrary lookup or fallback to the original host. Corruption, missing ro
|
|
|
40
49
|
unknown aliases, links and unregistered paths reject. Legacy deliveries retain
|
|
41
50
|
their original path and do not accept this resolver.
|
|
42
51
|
|
|
52
|
+
`--prepare-runtime-catalog INPUT` and `--export-runtime-materials INPUT` also
|
|
53
|
+
accept `--runtime-materials ABSOLUTE_MATERIAL_BUNDLE_JSON`. Their JSON input
|
|
54
|
+
keys are unchanged. For a newly supplied reuse Producer/delivery, only that
|
|
55
|
+
explicit new subgraph is read locally; its historical baseline stays within the
|
|
56
|
+
validated bundle. Missing historical mappings never fall back to the host.
|
|
57
|
+
The original two-argument import CLI and closed inventory checks are unchanged.
|
|
58
|
+
The catalog-set install/inspect CLI accepts the same option with an already
|
|
59
|
+
complete bundle. It resolves only the selected pairing's pinned subgraph; the
|
|
60
|
+
local input, current catalog, unselected profiles and original CAS/source gates
|
|
61
|
+
retain their existing boundaries.
|
|
62
|
+
|
|
43
63
|
For a final package or its later finalization from imported reuse material, the
|
|
44
64
|
existing release command accepts `--runtime-materials ABSOLUTE_MATERIAL_BUNDLE_JSON`
|
|
45
65
|
in addition to its normal pairing/finalization input. The bundle inventory is
|
|
@@ -48,6 +68,55 @@ finalization or bypass the final version/source/archive checks. Release tooling,
|
|
|
48
68
|
portable integrity, target installation and ordinary gameplay remain separate
|
|
49
69
|
verification stages; an engineering source/package fixture is not an issued Kit.
|
|
50
70
|
|
|
71
|
+
## Release-only WorldScene and Document catalog composition
|
|
72
|
+
|
|
73
|
+
The catalog prepare CLI accepts its original `producerFile`,
|
|
74
|
+
`clientsDeliveryFile`, `runtimeOrigin` and `outputDirectory` input. A Document
|
|
75
|
+
release may also supply `legacy: {producerFile, clientsDeliveryFile}` for the
|
|
76
|
+
existing WorldScene1.0 content family. Each pair goes through the original
|
|
77
|
+
Producer/delivery/manifest/target checks before the catalog is combined. Both
|
|
78
|
+
must bind the same release source, version, environment and complete toolchain;
|
|
79
|
+
the additional delivery is a normal Producer delivery, not a borrowed Document
|
|
80
|
+
companion or payload-reuse proof. No snapshot or content identity is converted.
|
|
81
|
+
An explicitly verified Document patch-reuse delivery can instead retain the
|
|
82
|
+
normal static Producer from its exact execution baseline. Its package, content,
|
|
83
|
+
reports and version keep their original identities. The new final carrier still
|
|
84
|
+
requires the same execution closure and complete verified dependency tree; an
|
|
85
|
+
unrelated historical Producer or a new static execution cannot be inferred.
|
|
86
|
+
The shared release binding describes the two internal Kit packages, not a
|
|
87
|
+
requirement for historical projects to adopt a new identity. Every historical
|
|
88
|
+
content tuple still needs genuine compatibility and execution evidence; a new
|
|
89
|
+
reference built by the current Kit cannot stand in for that historical input.
|
|
90
|
+
|
|
91
|
+
The release package and the content under test have separate identities. The
|
|
92
|
+
Producer's package, metadata, evidence, source and toolchain bind the new release
|
|
93
|
+
exactly. A retained content input keeps its original `expected` tuple and pinned
|
|
94
|
+
snapshot; when it differs from the carrier, the constructor reenters the existing
|
|
95
|
+
snapshot Reader rather than changing its tool fields. Each target report's `tool`
|
|
96
|
+
must equal that actual content's `expected.tool`, not the carrier version. The two
|
|
97
|
+
content families may therefore have different tool identities while sharing the
|
|
98
|
+
same release package/toolchain/source. This is not a version-range waiver: the
|
|
99
|
+
Runtime must declare and verify the exact content tuple, and the installed
|
|
100
|
+
package, execution target, original reports and cleanup remain independently
|
|
101
|
+
checked. A successful Producer or catalog check is not proof of historical Host
|
|
102
|
+
execution or of an unobserved project's compatibility.
|
|
103
|
+
|
|
104
|
+
The pairing keeps the Document `producer`, `clients` and `targets` unchanged,
|
|
105
|
+
and pins the WorldScene pair under `legacy: {producer, clients, targets}`.
|
|
106
|
+
Final verification reproduces both catalogs, checks the entire selected catalog,
|
|
107
|
+
and returns `legacyTargets` alongside the original `targets`. Catalog CAS and
|
|
108
|
+
source checks apply to both Producers. Removing either pair, changing its inputs
|
|
109
|
+
or manually adding a catalog entry cannot produce a matching final pairing.
|
|
110
|
+
|
|
111
|
+
Portable export/import transports the additional Producer, package, metadata,
|
|
112
|
+
evidence, content, complete snapshot, optional source lock and both target
|
|
113
|
+
manifests/archives/reports as closed `legacy-*` roles. Original logical JSON and
|
|
114
|
+
pins remain byte-identical, with no original-host fallback. The Document
|
|
115
|
+
companion proof and its existing roles are not extended to certify WorldScene.
|
|
116
|
+
This tooling support alone does not supply a playable static Room Runtime: its
|
|
117
|
+
trusted source contract, installed inspection, IPC, actual execution and public
|
|
118
|
+
immutable download must be verified separately before a release is recommended.
|
|
119
|
+
|
|
51
120
|
## Local selection failures
|
|
52
121
|
|
|
53
122
|
`dev` and `test` read the trusted catalog bundled with the CLI actually invoked,
|