@tiinex/core 0.11.0 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.11.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": "d9fce40b1ec63fb0e4dc0a673161650d1661a25c",
+  "gitHead": "a63df8c4736b3267ac0aefa769b1262f45b78dac",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "d9fce40b1ec63fb0e4dc0a673161650d1661a25c",
-    "sourceTree": "1827ddd3975215d019cb809f2d477de6ebc4b300",
+    "sourceCommit": "a63df8c4736b3267ac0aefa769b1262f45b78dac",
+    "sourceTree": "d502ba11f95bbaf29fb7b86015df3d7b63bc82eb",
     "repository": "Tiinex/core",
-    "previousVersion": "0.10.0"
+    "previousVersion": "0.11.0"
   }
 }

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
   });
 }