@tiinex/core 0.10.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -167,12 +167,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "3a1efbac38c1cabc1a0d85746ccaab8149d6162e",
+  "gitHead": "a63df8c4736b3267ac0aefa769b1262f45b78dac",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "3a1efbac38c1cabc1a0d85746ccaab8149d6162e",
-    "sourceTree": "8c1449869841737fb7b120b69d00b4854cfff334",
+    "sourceCommit": "a63df8c4736b3267ac0aefa769b1262f45b78dac",
+    "sourceTree": "d502ba11f95bbaf29fb7b86015df3d7b63bc82eb",
     "repository": "Tiinex/core",
-    "previousVersion": "0.9.0"
+    "previousVersion": "0.11.0"
   }
 }

package/src/tooling/portable/adapters/cli/cli.common-author.js

@@ -8,6 +8,7 @@ import { sha256Hex, utf8Bytes } from '../../../../export/package.bytes.js';
 import { resolveSchemaModule } from '../../../../schemas/resolver.js';
 import { loadNodePortableInput } from '../../input/node.input.js';
 import { runPortableOperation } from '../../operation.catalog.js';
+import { markPortableBootstrapCanonicalSource } from '../../providers/schema.bootstrap.provenance.js';
 import { allocateContinuationPath, allocateDirectoryArtifactPath } from '../../../../transitions/record.transitions.js';
 import { classifyParentRecoveryReference } from '../../../../lineage/parentRecoveryReference.js';
 
@@ -36,7 +37,7 @@ export async function runCommonAuthorCli(parsed = {}, runtime = {}) {
   const parentPath = parentReference ? (parentSource ? path.resolve(parentSource) : safeWorkspaceTarget(workspaceRoot, parentReference)) : '';
   const artifactRelativePath = requestedArtifactRelativePath || await allocateArtifactRelativePath({ workspaceRoot, targetDirectory, parentRelativePath: parentReference, schemaId, title });
   const artifactPath = safeWorkspaceTarget(workspaceRoot, artifactRelativePath);
-  const parentRecord = parentPath ? await parentRecordFromArtifact(parentPath, parentReference, { workspaceRoot, childRelativePath: artifactRelativePath }) : {};
+  const parentRecord = parentPath ? await parentRecordFromArtifact(parentPath, parentReference, { workspaceRoot, childRelativePath: artifactRelativePath, runtime }) : {};
   const transitionType = String(flags.transition || defaultTransition(schemaId, Boolean(parentPath))).trim();
   const contract = buildArtifactCreationContract({ schemaId, transitionType });
   const summary = String(flags.summary || title).trim();
@@ -128,7 +129,7 @@ async function parentRecordFromArtifact(parentPath, parentRelativePath, context
   if (self.state !== 'verified') throw new Error(`portable.cli.author.parent.integrity.${self.reason || self.state}`);
   const schemaReferenceAuthority = schemaTarget
     ? exactDeclaredSchemaReferenceAuthority(schemaId, schemaTarget)
-    : await recoverQualifiedLocalSchemaReferenceAuthority(schemaId, context);
+    : await recoverQualifiedRuntimeSchemaReferenceAuthority(schemaId, context.runtime || {});
   if (!schemaReferenceAuthority) throw new Error('portable.cli.author.parent.schema-authority.required');
   return Object.freeze({
     id: parentRelativePath,
@@ -159,48 +160,115 @@ function exactDeclaredSchemaReferenceAuthority(schemaId, schemaTarget) {
   });
 }
 
-async function recoverQualifiedLocalSchemaReferenceAuthority(schemaId, context = {}) {
-  const workspaceRoot = path.resolve(String(context.workspaceRoot || '.'));
-  const childRelativePath = normalizeWorkspaceRelativePath(context.childRelativePath || '');
+export async function recoverQualifiedRuntimeSchemaReferenceAuthority(schemaId, runtime = {}) {
   const resolution = resolveSchemaModule({ schemaId });
   const module = resolution?.fallbackUsed ? null : resolution?.module || null;
   const source = module?.schemaSource || null;
   const qualification = typeof source?.qualify === 'function' ? source.qualify() : null;
   const materialIdentity = qualification?.materialIdentity || {};
-  const bundledPath = normalizeWorkspaceRelativePath(source?.bundledPath || '');
   const expectedSha256 = String(materialIdentity.sha256 || qualification?.checksum || '').trim().toLowerCase();
   if (!module || String(module.id || '') !== schemaId) return null;
   if (qualification?.state !== 'qualified' || materialIdentity?.state !== 'qualified' || String(materialIdentity.schemaId || '') !== schemaId) return null;
-  if (!bundledPath || !childRelativePath || !expectedSha256) return null;
+  if (!expectedSha256) return null;
 
-  let localMarkdown;
-  try { localMarkdown = await readFile(safeWorkspaceTarget(workspaceRoot, bundledPath), 'utf8'); }
-  catch { return null; }
-  if (sha256Hex(utf8Bytes(localMarkdown)).toLowerCase() !== expectedSha256) return null;
+  const runtimeMaterial = await loadQualifiedRuntimeSchemaMaterial(schemaId, runtime);
+  if (!runtimeMaterial) return null;
+  const markdown = String(runtimeMaterial.markdown || '');
+  const observedSha256 = markdown ? sha256Hex(utf8Bytes(markdown)).toLowerCase() : '';
+  const observedBytes = markdown ? utf8Bytes(markdown).byteLength : 0;
+  if (!observedSha256 || observedSha256 !== expectedSha256) return null;
+  if (Number(materialIdentity.bytes || 0) > 0 && observedBytes !== Number(materialIdentity.bytes)) return null;
+  if (!exactRuntimeSchemaSourceIdentity(runtimeMaterial.source || {}, materialIdentity)) return null;
 
-  let localParsed;
-  try { localParsed = parseArtifactMarkdown(localMarkdown); }
-  catch { return null; }
-  if (String(localParsed.envelope?.current?.schema?.id || '').trim() !== schemaId) return null;
-
-  const childDir = path.posix.dirname(childRelativePath);
-  const preferredTarget = path.posix.relative(childDir === '.' ? '' : childDir, bundledPath);
-  if (!preferredTarget || path.posix.isAbsolute(preferredTarget)) return null;
+  const preferredTarget = durableRuntimeSchemaTarget(runtimeMaterial.source || {}, materialIdentity, runtime.defaultSchemaSource || {});
+  if (!preferredTarget) return null;
   return Object.freeze({
     schemaId,
     exactTargets: Object.freeze([preferredTarget]),
     preferredTarget,
     resolutionState: 'qualified',
-    targetAuthority: 'qualified-local-bundled-schema-material',
+    targetAuthority: 'qualified-runtime-canonical-schema-material',
     resolutionEvidence: Object.freeze({
       state: 'qualified',
-      kind: 'workspace-bundled-schema-byte-match',
-      workspacePath: bundledPath,
-      sha256: expectedSha256
+      kind: 'runtime-canonical-schema-byte-match',
+      target: preferredTarget,
+      materialIdentity: Object.freeze({
+        state: 'qualified',
+        schemaId,
+        sha256: observedSha256,
+        bytes: observedBytes,
+        sourceRepository: String(materialIdentity.sourceRepository || ''),
+        sourceCommit: String(materialIdentity.sourceCommit || ''),
+        sourcePath: String(materialIdentity.sourcePath || ''),
+        sourceBlobSha: String(materialIdentity.sourceBlobSha || '')
+      })
     })
   });
 }
 
+async function loadQualifiedRuntimeSchemaMaterial(schemaId, runtime = {}) {
+  const targets = normalizeRuntimePaths(runtime.defaultSchemaMaterialPaths);
+  if (!targets.length) return null;
+  const loaded = await loadNodePortableInput(targets);
+  if ((loaded.findings || []).some((finding) => finding?.severity === 'error')) return null;
+  const decorated = decorateRuntimeSchemaMaterial(loaded, runtime.defaultSchemaSource || {});
+  const resolved = await runPortableOperation('resolve-schema-material', { ...decorated, schemaId }, {});
+  if (resolved?.status !== 'resolved' || !resolved?.material) return null;
+  const material = resolved.material;
+  if (String(material.schemaId || '') !== schemaId) return null;
+  if (material.qualification?.sourceQualified !== true || material.qualification?.representationIntegrity !== 'verified') return null;
+  return material;
+}
+
+function decorateRuntimeSchemaMaterial(material = {}, source = {}) {
+  const repository = String(source.repository || '');
+  const commit = String(source.commit || source.ref || '');
+  const sourcePathPrefix = String(source.sourcePathPrefix || '.topics/.schemas').replace(/\/$/, '');
+  if (!repository || !commit || !sourcePathPrefix) return material;
+  return Object.freeze({
+    ...material,
+    files: Object.freeze((material.files || []).map((file) => Object.freeze({
+      ...file,
+      sourceMode: 'portable-bootstrap-canonical-schema',
+      source: markPortableBootstrapCanonicalSource({
+        providerId: 'bootstrap-canonical-schema-pack',
+        repository,
+        ref: commit,
+        commit,
+        path: `${sourcePathPrefix}/${file.path}`,
+        authority: 'canonical-core',
+        qualification: 'bundled-byte-bound-canonical-snapshot',
+        remoteFetch: false,
+        cached: false
+      })
+    })))
+  });
+}
+
+function exactRuntimeSchemaSourceIdentity(source = {}, materialIdentity = {}) {
+  const expected = {
+    repository: String(materialIdentity.sourceRepository || ''),
+    commit: String(materialIdentity.sourceCommit || ''),
+    path: String(materialIdentity.sourcePath || '')
+  };
+  const observed = {
+    repository: String(source.repository || ''),
+    commit: String(source.commit || source.ref || ''),
+    path: String(source.path || '')
+  };
+  if (!expected.repository || !expected.commit || !expected.path) return false;
+  return expected.repository === observed.repository && expected.commit === observed.commit && normalizeWorkspaceRelativePath(expected.path) === normalizeWorkspaceRelativePath(observed.path);
+}
+
+function durableRuntimeSchemaTarget(source = {}, materialIdentity = {}, runtimeSource = {}) {
+  const explicitTarget = String(runtimeSource.referenceTarget || '').trim();
+  if (explicitTarget) return explicitTarget;
+  const workspaceId = String(runtimeSource.workspaceId || '').trim();
+  const sourcePath = normalizeWorkspaceRelativePath(materialIdentity.sourcePath || source.path || '');
+  if (workspaceId && /^[A-Za-z0-9._-]+$/.test(workspaceId) && sourcePath) return `${workspaceId}::${sourcePath}`;
+  return '';
+}
+
 async function allocateArtifactRelativePath({ workspaceRoot, targetDirectory, parentRelativePath, schemaId, title } = {}) {
   const directory = normalizeWorkspaceRelativePath(targetDirectory || (parentRelativePath ? path.posix.dirname(parentRelativePath) : '.topics')) || '.topics';
   const existingPaths = await directoryArtifactPaths(workspaceRoot, directory);

package/src/tooling/portable/adapters/node/handoff.manufacture.bootstrap.js

@@ -14,6 +14,7 @@ export async function buildToolingBootstrapTransportFiles(input = {}) {
   const delivery = normalizeDelivery(input.delivery);
   const runtimeRoot = path.resolve(String(input.runtimeRoot || DEFAULT_RUNTIME_ROOT));
   const runtime = await enumerateRuntimeDependencyGraph(runtimeRoot, { maxFiles: input.maxFiles });
+  const runtimeIdentity = runtimeIdentityFromEnumeration(runtime);
   const manifest = Object.freeze({
     schema: PORTABLE_TOOLING_BOOTSTRAP_MANIFEST_SCHEMA_ID,
     version: 1,
@@ -30,7 +31,42 @@ export async function buildToolingBootstrapTransportFiles(input = {}) {
   const summary = Object.freeze({ schema: 'tiinex.portable.tooling-bootstrap.summary.v1', delivery, manifestSha256, representationSha256: runtime.representationSha256, runtimeFiles: runtime.entries.length, runtimeBytes: runtime.totalBytes, status: delivery === 'embedded' ? 'embedded-qualified' : 'persistent-identity-verified', persistentVerification });
   const files = [transportFile('tiinex.bootstrap/manifest.json', manifestBytes, 'tooling-bootstrap-manifest', 'portable-tooling-bootstrap-control')];
   if (delivery === 'embedded') for (const entry of runtime.entries) files.push(transportFile(`tiinex.bootstrap/runtime/${entry.path}`, entry.data, 'tooling-bootstrap-runtime', 'portable-tooling-bootstrap-runtime'));
-  return Object.freeze({ manifest, summary, files: Object.freeze(files) });
+  return Object.freeze({ manifest, summary, files: Object.freeze(files), runtimeIdentity });
+}
+
+export async function buildToolingBootstrapRuntimeIdentity(input = {}) {
+  const runtimeRoot = path.resolve(String(input.runtimeRoot || DEFAULT_RUNTIME_ROOT));
+  const runtime = await enumerateRuntimeDependencyGraph(runtimeRoot, { maxFiles: input.maxFiles });
+  return runtimeIdentityFromEnumeration(runtime);
+}
+
+
+function runtimeIdentityFromEnumeration(runtime = {}) {
+  const runtimeEntries = runtime.entries || [];
+  const packageEntry = runtimeEntries.find((entry) => String(entry?.path || '') === 'package.json');
+  let packageName = '';
+  let packageVersion = '';
+  if (packageEntry?.data) {
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(packageEntry.data));
+      packageName = String(parsed?.name || '').trim();
+      packageVersion = String(parsed?.version || '').trim();
+    } catch {}
+  }
+  const shaFor = (entryPath) => String(runtimeEntries.find((entry) => String(entry?.path || '') === entryPath)?.sha256 || '');
+  const sourceEntries = runtimeEntries.filter((entry) => String(entry?.path || '') !== 'package.json');
+  const sourceRepresentationSha256 = sha256Text(stableJson(sourceEntries.map(({ path: entryPath, bytes, sha256 }) => ({ path: `runtime/${entryPath}`, bytes, sha256 }))));
+  return Object.freeze({
+    schema: 'tiinex.portable.tooling-runtime-identity.v1',
+    packageName,
+    packageVersion,
+    representationSha256: String(runtime.representationSha256 || ''),
+    sourceRepresentationSha256,
+    runtimeFiles: Number(runtimeEntries.length),
+    runtimeBytes: Number(runtime.totalBytes || 0),
+    entrypointSha256: shaFor('tools/tiinex-portable.mjs'),
+    enumerationPolicySha256: shaFor('src/tooling/portable/adapters/node/handoff.manufacture.enumeration.js')
+  });
 }
 
 function verifyExpectedPersistentBootstrap(expected, manifest, manifestSha256) {

package/src/tooling/portable/adapters/node/handoff.manufacture.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { inferWorkspaceTitle, normalizeAdditionalWorkspaceDescriptors, normalizeTransportRoute, safeWorkspaceToken } from './handoff.manufacture.multiRoot.js';
 import { buildToolingBootstrapTransportFiles, PORTABLE_TOOLING_BOOTSTRAP_MANIFEST_SCHEMA_ID } from './handoff.manufacture.bootstrap.js';
+import { qualifyToolingRuntimeSourceAlignment } from './handoff.manufacture.runtimeSource.js';
 import { normalizeHandoffCarrierLineage } from '../../handoff/carrierLineage.js';
 import { normalizeHandoffCarrierProfile } from '../../handoff/carrierProfile.js';
 import { enumerateNodeWorkspace, PORTABLE_NODE_WORKSPACE_ENUMERATION_SCHEMA_ID } from './handoff.manufacture.enumeration.js';
@@ -153,6 +154,14 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
   const toolingBootstrapResult = await toolingBootstrapPromise;
   if (toolingBootstrapResult.error) throw toolingBootstrapResult.error;
   const toolingBootstrap = toolingBootstrapResult.value;
+  const runtimeSourceAlignment = await qualifyToolingRuntimeSourceAlignment({
+    runtimeIdentity: toolingBootstrap.runtimeIdentity,
+    localWorkspaces: [
+      Object.freeze({ id: workspaceId, root: workspaceRoot, materialization: primaryMaterialization }),
+      ...additionalEnumerations.map(({ id, root, enumerated }) => Object.freeze({ id, root, materialization: enumerated.materialization }))
+    ],
+    maxFiles: input.bootstrapMaxFiles || options.bootstrapMaxFiles
+  });
   const orientationBootstrap = input.transportBootstrapContent
     ? Object.freeze({ present: true, path: String(input.transportBootstrapPath || 'tiinex.package/bootstrap.md'), content: String(input.transportBootstrapContent), mediaType: 'text/markdown' })
     : Object.freeze({ present: false });
@@ -175,6 +184,7 @@ export async function prepareNodeHandoffManufacturingInput(input = {}, options =
       enumeration: enumeration.evidence,
       workspaceEnumerations: Object.freeze(workspaceEnumerations),
       toolingBootstrap: toolingBootstrap.summary,
+      runtimeSourceAlignment,
       packageParentWorkspaceReuse: Object.freeze({
         state: String(packageParentReuse.state || ''),
         providerState: String(packageParentReuse.providerState || ''),

package/src/tooling/portable/adapters/node/handoff.manufacture.runtimeSource.js

@@ -0,0 +1,82 @@
+import { buildToolingBootstrapRuntimeIdentity } from './handoff.manufacture.bootstrap.js';
+
+export const PORTABLE_TOOLING_RUNTIME_SOURCE_ALIGNMENT_SCHEMA_ID = 'tiinex.portable.tooling-runtime-source-alignment.v1';
+const CORE_PACKAGE_NAME = '@tiinex/core';
+
+export async function qualifyToolingRuntimeSourceAlignment(input = {}) {
+  const runtimeIdentity = normalizeIdentity(input.runtimeIdentity);
+  if (!runtimeIdentity.sourceRepresentationSha256) throw new Error('portable.tooling-bootstrap.runtime-source.runtime-identity-required');
+  const candidates = [];
+  for (const item of input.localWorkspaces || input.workspaces || []) {
+    const root = String(item?.root || '').trim();
+    if (!root) continue;
+    const materialization = item?.materialization || item?.enumeration?.materialization || null;
+    const packageIdentity = packageIdentityFromMaterialization(materialization);
+    if (packageIdentity.name !== CORE_PACKAGE_NAME) continue;
+    candidates.push(Object.freeze({
+      workspaceId: String(item?.id || materialization?.id || '').trim(),
+      root,
+      packageIdentity
+    }));
+  }
+  if (!candidates.length) return Object.freeze({
+    schema: PORTABLE_TOOLING_RUNTIME_SOURCE_ALIGNMENT_SCHEMA_ID,
+    state: 'not-observed',
+    coreWorkspaceCount: 0,
+    runtime: runtimeIdentity,
+    source: null,
+    boundary: 'No local Workspace with package identity @tiinex/core was selected, so exact runtime/source equality cannot be asserted from carried source.'
+  });
+  if (candidates.length !== 1) throw new Error(`portable.tooling-bootstrap.runtime-source.core-workspace-ambiguous:${candidates.map((item) => item.workspaceId || 'unlabeled').join(',')}`);
+
+  const candidate = candidates[0];
+  const sourceIdentity = normalizeIdentity(await buildToolingBootstrapRuntimeIdentity({
+    runtimeRoot: candidate.root,
+    maxFiles: input.maxFiles
+  }));
+  const evidence = Object.freeze({
+    schema: PORTABLE_TOOLING_RUNTIME_SOURCE_ALIGNMENT_SCHEMA_ID,
+    state: sourceIdentity.sourceRepresentationSha256 === runtimeIdentity.sourceRepresentationSha256 ? 'qualified-exact-match' : 'mismatch',
+    coreWorkspaceCount: 1,
+    workspaceId: candidate.workspaceId,
+    runtime: runtimeIdentity,
+    source: sourceIdentity,
+    boundary: 'Exact Tooling runtime source/data equality is required when a local @tiinex/core Workspace is carried. Release-normalized package.json metadata may differ, but matching package names or versions alone are insufficient.'
+  });
+  if (evidence.state !== 'qualified-exact-match') {
+    throw new Error([
+      'portable.tooling-bootstrap.runtime-source.mismatch',
+      `workspace=${candidate.workspaceId || 'unlabeled'}`,
+      `runtimeVersion=${runtimeIdentity.packageVersion || 'unknown'}`,
+      `sourceVersion=${sourceIdentity.packageVersion || candidate.packageIdentity.version || 'unknown'}`,
+      `runtimeSource=${runtimeIdentity.sourceRepresentationSha256}`,
+      `sourceSource=${sourceIdentity.sourceRepresentationSha256}`
+    ].join(':'));
+  }
+  return evidence;
+}
+
+function packageIdentityFromMaterialization(materialization) {
+  const entry = (materialization?.entries || []).find((item) => String(item?.path || '') === 'package.json');
+  if (!entry?.data) return Object.freeze({ name: '', version: '' });
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(entry.data));
+    return Object.freeze({ name: String(parsed?.name || '').trim(), version: String(parsed?.version || '').trim() });
+  } catch {
+    return Object.freeze({ name: '', version: '' });
+  }
+}
+
+function normalizeIdentity(value = {}) {
+  return Object.freeze({
+    schema: String(value?.schema || 'tiinex.portable.tooling-runtime-identity.v1'),
+    packageName: String(value?.packageName || ''),
+    packageVersion: String(value?.packageVersion || ''),
+    representationSha256: String(value?.representationSha256 || ''),
+    sourceRepresentationSha256: String(value?.sourceRepresentationSha256 || ''),
+    runtimeFiles: Number(value?.runtimeFiles || 0),
+    runtimeBytes: Number(value?.runtimeBytes || 0),
+    entrypointSha256: String(value?.entrypointSha256 || ''),
+    enumerationPolicySha256: String(value?.enumerationPolicySha256 || '')
+  });
+}

package/src/tooling/portable/adapters/node/workspaceCarrier.manufacture.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { enumerateNodeWorkspace } from './handoff.manufacture.enumeration.js';
 import { buildToolingBootstrapTransportFiles } from './handoff.manufacture.bootstrap.js';
+import { qualifyToolingRuntimeSourceAlignment } from './handoff.manufacture.runtimeSource.js';
 import { inferWorkspaceTitle, normalizeAdditionalWorkspaceDescriptors, safeWorkspaceToken } from './handoff.manufacture.multiRoot.js';
 import { normalizeWorkspaceTargetBindings } from './handoff.manufacture.scope.js';
 import { normalizeHandoffCarrierLineage } from '../../handoff/carrierLineage.js';
@@ -47,6 +48,11 @@ export async function prepareNodeWorkspaceCarrierManufacturingInput(input = {},
     expected: input.expectedToolingBootstrap || null,
     maxFiles: input.bootstrapMaxFiles || options.bootstrapMaxFiles
   });
+  const runtimeSourceAlignment = await qualifyToolingRuntimeSourceAlignment({
+    runtimeIdentity: toolingBootstrap.runtimeIdentity,
+    localWorkspaces: enumerations.map((item) => Object.freeze({ id: item.materialization.id, root: item.root, materialization: item.materialization })),
+    maxFiles: input.bootstrapMaxFiles || options.bootstrapMaxFiles
+  });
   return Object.freeze({
     carrierMode: 'workspace',
     createdAt: String(input.createdAt || ''),
@@ -56,7 +62,7 @@ export async function prepareNodeWorkspaceCarrierManufacturingInput(input = {},
     carrierLineage: normalizeHandoffCarrierLineage(input.carrierLineage || null),
     carrierProfile: normalizeHandoffCarrierProfile(input.carrierProfile || null),
     toolingBootstrap: toolingBootstrap.summary,
-    manufacturingEvidence: Object.freeze({ workspaceEnumerations: Object.freeze(enumerations.map((item) => Object.freeze({ id: item.materialization.id, root: item.root, evidence: item.evidence }))), toolingBootstrap: toolingBootstrap.summary }),
+    manufacturingEvidence: Object.freeze({ workspaceEnumerations: Object.freeze(enumerations.map((item) => Object.freeze({ id: item.materialization.id, root: item.root, evidence: item.evidence }))), toolingBootstrap: toolingBootstrap.summary, runtimeSourceAlignment }),
     verifyRoundtrip: input.verifyRoundtrip !== false
   });
 }

package/src/tooling/portable/schema/bootstrap/canonical.pack.js

@@ -6,6 +6,7 @@ export const PORTABLE_CANONICAL_BOOTSTRAP_ROOT = fileURLToPath(new URL(`./docs-$
 export const portableCanonicalBootstrapRuntime = Object.freeze({
   defaultSchemaMaterialPaths: Object.freeze([PORTABLE_CANONICAL_BOOTSTRAP_ROOT]),
   defaultSchemaSource: Object.freeze({
+    workspaceId: 'docs',
     repository: 'Tiinex/docs',
     commit: PORTABLE_CANONICAL_BOOTSTRAP_DOCS_COMMIT,
     sourcePathPrefix: '.topics/.schemas'