@tiinex/core 0.17.0 → 0.19.0

package/src/tooling/portable/handoff/delegationReturnReservation.js

@@ -32,14 +32,16 @@ export function qualifyDelegationReturnReservation(input = {}) {
     });
   }
 
+  const rawSupplied = rawIndex !== undefined && rawIndex !== null && String(rawIndex).trim() !== '';
   const siblingIndex = parseSiblingIndex(rawIndex);
-  if (siblingIndex === null) findings.push(finding('error', 'portable.delegation-return-reservation.sibling-index.required', 'A return Handoff is transport-not-ready until the delegator supplies one explicit non-Major return package sibling index in the supported range 1..9999.'));
+  if (rawSupplied && siblingIndex === null) findings.push(finding('error', 'portable.delegation-return-reservation.sibling-index.invalid', 'Explicit return package sibling override must be an integer in the supported range 1..9999.'));
   return freeze({
     schema: PORTABLE_DELEGATION_RETURN_RESERVATION_SCHEMA_ID,
     state: findings.length ? 'blocked' : 'qualified',
     returnExpected: true,
     carrierKind: 'non-major',
     siblingIndex,
+    allocationMode: siblingIndex === null ? 'derive-from-qualified-recipient-selected-pointer' : 'explicit-advanced-override',
     findings,
     boundary: boundary()
   });
@@ -95,7 +97,7 @@ function field(section = '', name = '') {
   const match = String(section || '').match(new RegExp(`^\\s*-\\s+${escapeRegExp(name)}\\s*:\\s*(.+?)\\s*$`, 'mi'));
   return String(match?.[1] || '').trim();
 }
-function boundary() { return 'Transport preflight only. It validates an explicit delegator-coordinated return reservation and never allocates, discovers, increments, guesses, recycles, or promotes a sibling index into semantic Parent, Workspace, Role, acceptance, or completion authority.'; }
+function boundary() { return 'Transport preflight only. Ordinary non-Major return allocation is derived later from the exact qualified selected parent Handoff Pointer ordinal; an explicit return sibling index is an advanced compatibility override only. This projection never promotes transport allocation into semantic Parent, Workspace, Role, acceptance, completion, participant, process, or source authority.'; }
 function finding(severity, code, message) { return Object.freeze({ severity, code, message }); }
 function escapeRegExp(value = '') { return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
 function freeze(value) { if (Array.isArray(value)) return Object.freeze(value.map(freeze)); if (!value || typeof value !== 'object' || Object.isFrozen(value)) return value; return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, freeze(item)]))); }

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

@@ -77,6 +77,7 @@ export function manufactureRecipientRelativeHandoffPackage(input = {}, options =
     roundtrip: upgraded.roundtrip || null,
     toolingBootstrap: input.toolingBootstrap || null,
     manufacturingEvidence: input.manufacturingEvidence || null,
+    carrierAllocation: input.carrierAllocation || input.manufacturingEvidence?.carrierAllocation || null,
     schemaReferencePreflight,
     returnCarrierReservationPreflight,
     reconciliationProofQualification,

package/src/tooling/portable/handoff/recipientV2.inspect.projection.js

@@ -5,6 +5,7 @@ export function projectRecipientV2Routes(routePointers = [], endpointPointers =
     const qualified = (qualifiedRoutes || []).find((route) => String(route.workspaceId || '') === String(item.facts?.workspaceId || '') && String(route.workspaceRelativePath || '') === String(item.facts?.workspaceRelativeHandoffPath || '')) || null;
     return Object.freeze({
     pointerPath: item.path,
+    routeId: String(item.facts?.routeId || qualified?.id || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     workspaceRelativeHandoffPath: String(item.facts?.workspaceRelativeHandoffPath || ''),
     returnCarrierReservation: item.facts?.returnCarrierReservation || qualified?.returnCarrierReservation || null,
@@ -17,6 +18,7 @@ export function projectRecipientV2Routes(routePointers = [], endpointPointers =
 export function projectRecipientV2EndpointRoles(pointers = []) {
   return Object.freeze(pointers.map((item) => Object.freeze({
     pointerPath: item.path,
+    routeId: String(item.facts?.routeId || qualified?.id || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     routeId: String(item.facts?.routeId || ''),
     requirementId: String(item.facts?.endpointRequirementId || ''),
@@ -36,6 +38,7 @@ export function projectRecipientV2EndpointRoles(pointers = []) {
 export function projectRecipientV2ParticipantRoles(pointers = []) {
   return Object.freeze(pointers.map((item) => Object.freeze({
     pointerPath: item.path,
+    routeId: String(item.facts?.routeId || qualified?.id || ''),
     workspaceId: String(item.facts?.workspaceId || ''),
     routeId: String(item.facts?.routeId || ''),
     roleLabelHint: String(item.facts?.roleLabelHint || ''),

package/src/tooling/portable/handoff/recipientV2.packageV1.inspect.js

@@ -256,7 +256,7 @@ export function inspectRecipientFacingV2PackageV1(bundle = {}, options = {}) {
   return deepFreeze({
     schema: 'tiinex.portable.recipient-facing-handoff-package-v1.inspection.v1', detected: Boolean(packageFile), status, format: RECIPIENT_V2_PACKAGE_V1_FORMAT_ID,
     rootArtifact: packageFile ? Object.freeze({ path: packageFile.path, schemaId: RECIPIENT_V2_PACKAGE_V1_SCHEMA_ID, sha256: sha256Hex(packageFileBytes(packageFile)), carrierLineage: lineage }) : null,
-    readArtifact, workspaces: Object.freeze(workspaceParts.map((item) => Object.freeze({ workspaceId: item.workspaceId, coverage: String(item.representation?.coverage || item.facts?.coverage || 'complete'), bindingState: item.bindingState || String(item.representation?.bindingState || 'verified'), workspaceArtifactPath: item.artifact.path, workspaceArchivePath: item.archiveFile?.path || '', sourceWorkspaceTargetInnerPath: item.facts.sourceWorkspaceTargetInnerPath, sourceWorkspaceTargetSha256: item.facts.sourceWorkspaceTargetSha256 }))), sealedWorkspaces: Object.freeze(sealedWorkspaceBindings),
+    readArtifact, workspaces: Object.freeze(workspaceParts.map((item) => Object.freeze({ workspaceId: item.workspaceId, coverage: String(item.representation?.coverage || item.facts?.coverage || 'complete'), bindingState: item.bindingState || String(item.representation?.bindingState || 'verified'), workspaceArtifactPath: item.artifact.path, workspaceRepresentationArtifactPath: String(item.representationArtifact?.path || ''), workspacePayloadArtifactPath: String(item.payloadArtifact?.path || item.protectedPayloadArtifact?.path || ''), workspaceArchivePath: item.archiveFile?.path || '', sourceWorkspaceTargetInnerPath: item.facts.sourceWorkspaceTargetInnerPath, sourceWorkspaceTargetSha256: item.facts.sourceWorkspaceTargetSha256 }))), sealedWorkspaces: Object.freeze(sealedWorkspaceBindings),
     routes: projectRecipientV2Routes(routePointers, endpointRolePointers, participantRolePointers, carrierProjection?.routes || []), endpointRoles: projectRecipientV2EndpointRoles(endpointRolePointers), participantRoles: projectRecipientV2ParticipantRoles(participantRolePointers),
     caches: Object.freeze(caches.map((cache) => Object.freeze({ workspaceId: String(cache.facts?.workspaceId || ''), artifactPath: cache.artifact.path, archivePath: cache.file.path, materials: cache.facts.materials || [] }))),
     bootstrapInspection, transportManifest: null, artifactFacts: Object.freeze(generatedArtifacts.map((item) => Object.freeze({ path: item.path, facts: item.facts }))), descriptor, workspaceByteProvider, carrierProjection, coldConsumerProjection,

package/src/tooling/portable/handoff/recoveryAcceptanceAudit.js

@@ -8,8 +8,8 @@ export function auditPortableRecoveryAcceptance(input = {}) {
   const basisInspection = inspectRecipientFacingV2Topology(input.basis?.bundle || input.basis || {});
   const candidateInspection = inspectRecipientFacingV2Topology(input.candidate?.bundle || input.candidate || {});
   const findings = [];
-  if (String(basisInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.basis-unqualified', 'Recovery acceptance audit requires one independently qualified accepted-basis Handoff package.'));
-  if (String(candidateInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.candidate-unqualified', 'Recovery acceptance audit requires one independently qualified candidate Handoff package.'));
+  if (String(basisInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.basis-unqualified', 'Recovery acceptance audit requires one independently qualified accepted-basis recipient-facing carrier. A qualified pointerless Workspace package is permitted; Handoff routing is not required for the accepted basis.'));
+  if (String(candidateInspection.status || '') !== 'valid') findings.push(finding('error', 'portable.recovery-acceptance.candidate-unqualified', 'Recovery acceptance audit requires one independently qualified candidate recipient-facing carrier. Candidate restart suitability still requires complete selected Workspace coverage.'));
   if (findings.some((item) => item.severity === 'error')) return auditResult('blocked', [], findings, basisInspection, candidateInspection, input);
 
   const candidateIds = [...new Set((candidateInspection.workspaces || []).map((item) => normalizeId(item.workspaceId)).filter(Boolean))].sort();
@@ -92,7 +92,9 @@ function auditResult(status, workspaces, findings, basisInspection, candidateIns
     status,
     state: status === 'ready' && allReady ? 'acceptance-audit-ready' : 'acceptance-audit-blocked',
     basisQualification: String(basisInspection.status || 'invalid'),
+    basisCarrierRole: String(basisInspection.packageContract?.packageRole || ''),
     candidateQualification: String(candidateInspection.status || 'invalid'),
+    candidateCarrierRole: String(candidateInspection.packageContract?.packageRole || ''),
     selectionMode: (input.workspaceIds || input.selectedWorkspaceIds || []).length ? 'explicit-workspace-set' : 'all-candidate-workspaces',
     workspaces: freeze(workspaces),
     counts: freeze({ workspaces: workspaces.length, readyWorkspaces: workspaces.filter((item) => item.state === 'ready').length, completeWorkspaces: completeWorkspaceCount, unexplainedRemovals: unexplainedRemovalCount }),
@@ -106,7 +108,7 @@ function auditResult(status, workspaces, findings, basisInspection, candidateIns
       semanticAcceptanceGranted: false
     }),
     findings: freeze(findings),
-    boundary: 'Coarse Recovery acceptance audit over already-qualified carrier bytes. It decodes the exact candidate Workspace representations, compares them to one explicit accepted basis, and fails on unexplained source removals or incomplete coverage. It does not inspect a live checkout, prove Git cleanliness/committability, decide semantic correctness, authorize deletion, or grant Master Recovery acceptance; target landing still requires the separate exact source preflight.'
+    boundary: 'Coarse Recovery acceptance audit over already-qualified recipient-facing carrier bytes. The accepted basis may be a routed Handoff carrier or a qualified pointerless Workspace carrier; route authority is not required merely to establish exact basis bytes. It decodes the exact candidate Workspace representations, compares them to one explicit accepted basis, and fails on unexplained source removals or incomplete candidate coverage. It does not inspect a live checkout, prove Git cleanliness/committability, decide semantic correctness, authorize deletion, or grant Master Recovery acceptance; target landing still requires the separate exact source preflight.'
   });
 }
 

package/src/tooling/portable/schema/contract.field-domain.js

@@ -52,12 +52,13 @@ export function validatePortableFieldDomains(input = {}) {
       }));
 
       if (qualification === 'invalid') {
+        const contractGuidance = fieldDomainContractGuidance(results);
         findings.push(fieldDomainFinding(
           'error',
           'portable.contract.field-domain.value.invalid',
-          `Value is outside the allowed field domain for ${bucket.group}.${bucket.field}: ${occurrence.value}.`,
+          invalidFieldDomainMessage(bucket.group, bucket.field, occurrence.value, contractGuidance),
           'structurally-invalid',
-          { group: bucket.group, field: bucket.field, value: occurrence.value, owner: occurrence.owner, contributions: results }
+          { group: bucket.group, field: bucket.field, value: occurrence.value, owner: occurrence.owner, contributions: results, contractGuidance }
         ));
       } else if (qualification === 'extension-candidate') {
         findings.push(fieldDomainFinding(
@@ -242,6 +243,46 @@ function fieldDomainFinding(severity, code, message, state, extra = {}) {
   return portableFinding(severity, code, message, { ...extra, state });
 }
 
+function fieldDomainContractGuidance(results = []) {
+  const contributions = (results || []).map((item) => Object.freeze({
+    sourceSchemaId: String(item.sourceSchemaId || ''),
+    sourceGroup: String(item.sourceGroup || ''),
+    field: String(item.field || ''),
+    allowedValues: Object.freeze([...(item.allowedValues || [])].map(String)),
+    allowedShapes: Object.freeze([...(item.allowedShapes || [])].map(String)),
+    domainPolicy: String(item.domainPolicy || ''),
+    declarationLine: Number(item.declarationLine || 0),
+    contractPath: [
+      String(item.sourceSchemaId || ''),
+      String(item.sourceGroup || ''),
+      'Field Value Constraints',
+      String(item.field || '')
+    ].filter(Boolean).join(' :: ')
+  }));
+  return Object.freeze({
+    contributions: Object.freeze(contributions),
+    nextAction: contributions.length === 1
+      ? `Use one value/shape allowed by ${contributions[0].contractPath || 'the cited field-domain contract'}; do not invent an extension unless the declared domain policy authorizes one.`
+      : 'Satisfy every contributing field-domain authority. Review each exact contractPath below; do not treat values from separate contributions as a union unless the contracts themselves establish that.'
+  });
+}
+
+function invalidFieldDomainMessage(group, field, value, guidance = {}) {
+  const contributions = guidance.contributions || [];
+  if (contributions.length === 1) {
+    const item = contributions[0];
+    const allowed = item.allowedValues || [];
+    const shapes = item.allowedShapes || [];
+    const domain = [
+      allowed.length ? `Allowed values: ${allowed.join(', ')}` : '',
+      shapes.length ? `Allowed shapes: ${shapes.join(', ')}` : ''
+    ].filter(Boolean).join('; ');
+    const path = item.contractPath ? ` Contract: ${item.contractPath}${item.declarationLine ? ` (line ${item.declarationLine})` : ''}.` : '';
+    return `Value is outside the allowed field domain for ${group}.${field}: ${value}.${domain ? ` ${domain}.` : ''}${path}`;
+  }
+  return `Value is outside the allowed field domain for ${group}.${field}: ${value}. Multiple field-domain authorities apply; see contractGuidance for each exact contract path and allowed values/shapes.`;
+}
+
 function exact(value = '') {
   return String(value || '').trim();
 }