@tiinex/core 0.27.0 → 0.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiinex/core",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "description": "Shared host-neutral Tiinex implementation core for artifacts, schemas, validation, lineage, grounding, Handoffs, provenance and deterministic workflows.",
   "type": "module",
   "sideEffects": true,
@@ -173,12 +173,12 @@
     "type": "git",
     "url": "git+https://github.com/Tiinex/core.git"
   },
-  "gitHead": "a7e75e17b1b95c022875c2006d2957d8cce580ae",
+  "gitHead": "d2ab9eeaaf1a0c0d13e2d7a5f9de4d010cf5e5bb",
   "tiinexRelease": {
     "policy": "tiinex.master-npm-release.v1",
-    "sourceCommit": "a7e75e17b1b95c022875c2006d2957d8cce580ae",
-    "sourceTree": "e86d119618fcd9cdc48bff5b016546f79bb7bcaa",
+    "sourceCommit": "d2ab9eeaaf1a0c0d13e2d7a5f9de4d010cf5e5bb",
+    "sourceTree": "50ae220f210ec6551825735fb7d9ba8f7956edc5",
     "repository": "Tiinex/core",
-    "previousVersion": "0.26.0"
+    "previousVersion": "0.28.0"
   }
 }

package/src/schemas/creation.contracts.js

@@ -173,7 +173,10 @@ export function validateArtifactCreationResult(draft = {}, parentRecord = {}, op
 
   if (rootCreation) findings.push(...validateRootCreationRepresentation(draft.markdown || '', contract));
   else if (parentExpected) {
-    const relativeReference = relativePath(dirname(options.childPath || draft.path || ''), parentRecord.path || '');
+    const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim();
+    const relativeReference = recoveryMode === 'workspace-qualified'
+      ? String(parentRecord.relativeReference || parentRecord.path || '')
+      : relativePath(dirname(options.childPath || draft.path || ''), parentRecord.path || '');
     const parentIntegrityTarget = qualifiedParentIntegrityTarget(parentRecord, relativeReference);
     const representation = qualifyContinuationCreationRepresentation(draft.markdown || '', contract, parentRecord, { relativeReference, parentIntegrityTarget });
     findings.push(...(representation.findings || []).map((message, index) => error(`creation.continuation-representation.${index + 1}`, message)));
@@ -221,7 +224,8 @@ function qualifiedParentIntegrityTarget(parentRecord = {}, relativeReference = '
   const published = parentRecord?.publishedReference || parentRecord?.browseGitReference || parentRecord?.browseGit || null;
   const target = typeof published === 'string' ? '' : String(published?.target || published?.url || '');
   const state = typeof published === 'string' ? 'unresolved' : String(published?.state || published?.resolutionState || 'unresolved');
-  const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+  const declaredRecoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim();
+  const recoveryMode = declaredRecoveryMode === 'external-versioned' ? 'external-versioned' : declaredRecoveryMode === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
   if (recoveryMode === 'external-versioned') return state === 'qualified' && target ? target : '';
   return state === 'qualified' && target ? target : String(relativeReference || '');
 }

package/src/schemas/creation.representation.js

@@ -217,7 +217,8 @@ export function qualifyContinuationCreationRepresentation(markdown = '', contrac
     const publishedTarget = typeof publishedReference === 'string' ? '' : String(publishedReference?.target || publishedReference?.url || '');
     const publishedState = typeof publishedReference === 'string' ? 'unresolved' : String(publishedReference?.state || publishedReference?.resolutionState || 'unresolved');
     const publishedQualified = Boolean(publishedTarget && publishedState === 'qualified');
-    const recoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+    const declaredRecoveryMode = String(parentRecord?.recoveryMode || parentRecord?.parentRecoveryMode || '').trim();
+    const recoveryMode = declaredRecoveryMode === 'external-versioned' ? 'external-versioned' : declaredRecoveryMode === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
     if (recoveryMode === 'external-versioned') {
       if (!publishedQualified) findings.push('External Parent recovery requires one qualified version-stable published representation.');
       if (origins.length !== 1 || relative.length !== 0 || browse.length !== 1) findings.push('External Parent Origin must contain exactly one [browse + git](...) entry and must not fabricate [relative](...).');

package/src/tooling/portable/adapters/cli/cli.command-input.js

@@ -182,6 +182,7 @@ export async function commandInput(parsed, runtime = {}) {
     options: {}
   };
   if(parsed.command==='project-workspace-landing')return land(flags,material,readOptionalJson,splitFlag);
+  if (parsed.command === 'project-authoring-parent') return { input: { ...material, reference: flags.reference || '' }, options: {} };
   const operatorBridgeInput = await prepareOperatorBridgeCliInput(parsed.command, material, flags, readOptionalJson);
   if (operatorBridgeInput) return operatorBridgeInput;
   if (parsed.command === 'project-editor-assistance') return prepareEditorAssistanceCliInput(material, flags);

package/src/tooling/portable/draft/draft.exact.js

@@ -16,6 +16,7 @@ export function normalizePortableParentRecord(parent = {}) {
     boundary: String(parent.boundary || parent.source?.boundary || ''),
     sourceMode: String(parent.sourceMode || ''),
     recoveryMode: String(parent.recoveryMode || parent.parentRecoveryMode || ''),
+    relativeReference: String(parent.relativeReference || ''),
     source: parent.source || null,
     markdown: String(parent.markdown || ''),
     integrity: parent.integrity || null,
@@ -108,11 +109,14 @@ export function qualifyPortableRenderedParentRepresentation(markdown = '', paren
   const observed = parsed.envelope?.parent || {};
   const hasObserved = Boolean(observed.schema?.id || observed.trace || observed.origin || observed.createdAt || observed.boundary || observed.originEntries?.length);
   if (rootCreation) return Object.freeze({ state: hasObserved ? 'invalid' : 'qualified', reason: hasObserved ? 'exact-result-parent-unexpected' : '' });
-  const relative = relativePath(dirname(childPath), parent.path);
   const published = parent.publishedReference || {};
   const publishedTarget = String(published.target || '');
   const publishedQualified = Boolean(publishedTarget && published.state === 'qualified');
-  const recoveryMode = String(parent.recoveryMode || '').trim() === 'external-versioned' ? 'external-versioned' : 'local-relative';
+  const declaredRecoveryMode = String(parent.recoveryMode || '').trim();
+  const recoveryMode = declaredRecoveryMode === 'external-versioned' ? 'external-versioned' : declaredRecoveryMode === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
+  const relative = recoveryMode === 'workspace-qualified'
+    ? String(parent.relativeReference || parent.path || '')
+    : relativePath(dirname(childPath), parent.path);
   const schemaTarget = String(parent.schemaReferenceAuthority?.preferredTarget || '');
   const origins = observed.originEntries || [];
   const createdAtLines = renderedParentFieldLines(markdown, 'Created At');

package/src/tooling/portable/editor/authoring.parent.js

@@ -1,5 +1,7 @@
 import { parseArtifactMarkdown } from '../../../artifacts/artifact.parse.js';
 import { auditPortableRecord } from '../audit/audit.capability.js';
+import { classifyParentRecoveryReference } from '../../../lineage/parentRecoveryReference.js';
+import { buildArtifactCreationContract } from '../../../schemas/creation.contracts.js';
 
 export const PORTABLE_AUTHORING_PARENT_SCHEMA_ID = 'tiinex.portable.authoring-parent.v1';
 
@@ -15,13 +17,24 @@ export function projectPortableAuthoringParent(input = {}) {
   const schemaId = String(parsed.envelope?.current?.schema?.id || audit.schemaId || '');
   const schemaTarget = String(parsed.envelope?.current?.schema?.target || '');
   const createdAt = String(parsed.envelope?.current?.createdAt || audit.artifact?.createdAt || '');
+  const explicitReference = String(input.reference || '').trim();
+  const projectedPath = explicitReference || String(record.path || record.id || '');
+  const referenceClassification = classifyParentRecoveryReference(projectedPath);
+  if (referenceClassification.kind === 'malformed-workspace-qualified') return freeze({ schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID, status: 'blocked', parentRecord: null, findings: [{ severity: 'error', code: 'portable.authoring-parent.reference.malformed', message: 'Selected Parent reference is malformed and cannot be used for native authoring.' }], operationBoundary: boundary() });
+  const recoveryMode = referenceClassification.kind === 'workspace-qualified' ? 'workspace-qualified' : 'local-relative';
+  const canonicalCurrent = buildArtifactCreationContract({ schemaId, transitionType: 'continue-from-record' })?.schemaReferences?.current || null;
+  const canonicalTargets = new Set([...(canonicalCurrent?.exactTargets || []), String(canonicalCurrent?.preferredTarget || '')].filter(Boolean));
+  const schemaReferenceQualified = Boolean(schemaTarget && canonicalCurrent?.resolutionState === 'qualified' && canonicalTargets.has(schemaTarget));
+  const schemaReferenceAuthority = schemaReferenceQualified
+    ? { ...canonicalCurrent, preferredTarget: schemaTarget, resolutionState: 'qualified', resolutionEvidence: { ...(canonicalCurrent?.resolutionEvidence || {}), basis: 'declared-parent-target-exact-canonical-match' } }
+    : { schemaId, preferredTarget: schemaTarget, exactTargets: schemaTarget ? [schemaTarget] : [], resolutionState: 'unresolved', evidence: { basis: 'declared-current-schema-reference-only' } };
   return freeze({
     schema: PORTABLE_AUTHORING_PARENT_SCHEMA_ID,
     status: 'ready',
     parentRecord: {
-      id: String(record.path || record.id || ''), path: String(record.path || record.id || ''), schemaId, currentSchemaId: schemaId, currentCreatedAt: createdAt,
+      id: projectedPath, path: projectedPath, schemaId, currentSchemaId: schemaId, currentCreatedAt: createdAt, createdAt, recoveryMode, relativeReference: recoveryMode === 'workspace-qualified' ? projectedPath : '',
       markdown: record.markdown, sourceMode: String(record.sourceMode || 'portable-node-local'),
-      schemaReferenceAuthority: { schemaId, preferredTarget: schemaTarget, exactTargets: schemaTarget ? [schemaTarget] : [], resolutionState: 'unresolved', evidence: { basis: 'declared-current-schema-reference-only' } }
+      schemaReferenceAuthority
     },
     findings: [],
     operationBoundary: boundary(),

package/src/tooling/portable/materialization/epistemic.plan.js

@@ -4,7 +4,8 @@ import { normalizePortableInput } from '../input/portable.input.js';
 import { portableFinding, summarizePortableFindings } from '../findings.js';
 import { planPortableArtifact } from '../schema/schema.guide.js';
 import { indexPortableLoadedParentRecords, projectPortableLoadedParentRecord, resolvePortableLoadedParentReference } from './loaded.parent.js';
-import { allocateContinuationPath, allocateRootArtifactPath } from '../../../transitions/record.transitions.js';
+import { allocateContinuationPath, allocateDirectoryArtifactPath, allocateRootArtifactPath } from '../../../transitions/record.transitions.js';
+import { normalizePortableParentRecord, qualifyPortableExactParent } from '../draft/draft.exact.js';
 
 export const PORTABLE_EPISTEMIC_PLAN_SCHEMA_ID = 'tiinex.portable.epistemic-materialization-plan.v1';
 
@@ -69,18 +70,20 @@ function planProposal({ proposal, index, proposals, proposalIds, loadedIndex, ma
   const clarificationNeeds = [];
   const contract = buildArtifactCreationContract({ schemaId: proposal.schemaId, transitionType: proposal.parentRef ? 'continue-from-record' : 'create-artifact' });
   const artifactPlan = planPortableArtifact({ ...material, schemaId: proposal.schemaId, task: proposal.parentRef ? 'continue' : 'create', values: proposal.values || {}, inputs: proposal.values || {} }, options);
-  const parent = resolveParentReference(proposal.parentRef, { loadedIndex, proposalIds, proposalIndex: index, proposals });
+  const parent = resolveParentReference(proposal.parentRef, { loadedIndex, proposalIds, proposalIndex: index, proposals, suppliedParentRecord: proposal.parentRecord });
   const parentForAllocation = parent.status === 'resolved'
     ? parent.kind === 'proposal'
       ? plannedParentRecord(plannedById.get(parent.parent?.proposalId || ''))
       : parent.parent
     : null;
-  const allocationOptions = Object.freeze({ existingPaths: Object.freeze([...occupiedPaths]), path: proposal.path || '' });
+  const allocationOptions = Object.freeze({ existingPaths: Object.freeze([...occupiedPaths]), path: proposal.path || '', targetDirectory: proposal.targetDirectory || '' });
   const allocated = proposal.parentRef && parentForAllocation
     ? allocateContinuationPath({ parentRecord: parentForAllocation, targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
-    : !proposal.parentRef
-      ? allocateRootArtifactPath({ targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
-      : Object.freeze({ path: proposal.path || '', policy: Object.freeze({}) });
+    : !proposal.parentRef && proposal.targetDirectory
+      ? allocateDirectoryArtifactPath({ targetDirectory: proposal.targetDirectory, targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
+      : !proposal.parentRef
+        ? allocateRootArtifactPath({ targetId: proposal.schemaId, targetLabel: proposal.schemaId, title: proposal.title || proposal.summary || proposal.id }, allocationOptions)
+        : Object.freeze({ path: proposal.path || '', policy: Object.freeze({}) });
 
   if (!proposal.schemaId) {
     findings.push(portableFinding('error', 'portable.materialization.schema.required', 'Each proposal must declare an implemented schema id; schema meaning is never inferred by the writer.', { proposalId: proposal.id }));
@@ -130,6 +133,7 @@ function planProposal({ proposal, index, proposals, proposalIds, loadedIndex, ma
     rationale: proposal.rationale,
     evidenceRefs: proposal.evidenceRefs,
     parentRef: proposal.parentRef,
+    targetDirectory: proposal.targetDirectory,
     parent: parent.status === 'resolved' ? parent.parent : null,
     parentKind: parent.status === 'resolved' ? parent.kind : '',
     creationContract: contract,
@@ -148,6 +152,8 @@ function normalizeProposals(value) {
       mode: clean(raw.mode || ''),
       schemaId: clean(raw.schemaId || raw.schema || ''),
       parentRef: exact(raw.parentRef ?? raw.parent ?? ''),
+      parentRecord: raw.parentRecord && typeof raw.parentRecord === 'object' ? Object.freeze(clone(raw.parentRecord)) : null,
+      targetDirectory: clean(raw.targetDirectory || raw.directory || ''),
       path: clean(raw.path || ''),
       title: clean(raw.title || ''),
       summary: clean(raw.summary || ''),
@@ -168,9 +174,17 @@ function plannedParentRecord(entry = null) {
   return Object.freeze({ id: entry.id || '', path: entry.path, schemaId: entry.schemaId || '', title: entry.title || entry.summary || entry.id || '' });
 }
 
-function resolveParentReference(ref, { loadedIndex, proposalIds, proposalIndex, proposals }) {
+function resolveParentReference(ref, { loadedIndex, proposalIds, proposalIndex, proposals, suppliedParentRecord = null }) {
   if (!ref) return { status: 'none', kind: 'none', parent: null };
   const reference = exact(ref);
+  if (suppliedParentRecord && typeof suppliedParentRecord === 'object') {
+    const normalized = normalizePortableParentRecord(suppliedParentRecord);
+    const declared = new Set([exact(normalized.id), exact(normalized.path)].filter(Boolean));
+    if (!declared.has(reference)) return { status: 'mismatch', code: 'portable.materialization.parent.supplied-reference-mismatch', message: 'The supplied Parent record does not identify the declared Parent reference.', candidates: [...declared] };
+    const qualification = qualifyPortableExactParent(normalized, 'continue-from-record');
+    if (!['qualified', 'qualified-local-continuity'].includes(String(qualification.state || ''))) return { status: 'unqualified', code: `portable.materialization.parent.supplied-${qualification.reason || 'unqualified'}`, message: 'The supplied Parent record is not qualified for continuation authoring.', candidates: [] };
+    return { status: 'resolved', kind: 'supplied-record', parent: qualification.snapshot };
+  }
   const proposalRef = reference.startsWith('proposal:') ? reference.slice('proposal:'.length) : proposalIds.has(reference) ? reference : '';
   if (proposalRef) {
     const targetIndex = proposals.findIndex((proposal) => proposal.id === proposalRef);

package/src/tooling/portable/workspace/workspace.initialize.js

@@ -46,7 +46,7 @@ export function preparePortableWorkspaceInitialization(input = {}) {
   if (!integrityTarget) findings.push(finding('error', 'workspace.initialize.integrity-method.unresolved', 'Core could not resolve canonical c14n-v2 validator authority.'));
   if (findings.some((item) => item.severity === 'error')) return blocked(findings);
 
-  const entrypoint = repository ? `\n## Workspace Entrypoints\n\n### Repository source\n\n- Source Kind: ${sourceKind}\n- Repository: ${repository}${ref ? `\n- Ref: ${ref}` : ''}\n- Root Path: ${rootPath}\n- Repo Files Discovery: on\n` : '';
+  const entrypoint = repository ? `\n\n## Workspace Entrypoints\n\n### Repository source\n\n- Source Kind: ${sourceKind}\n- Repository: ${repository}${ref ? `\n- Ref: ${ref}` : ''}\n- Root Path: ${rootPath}\n- Repo Files Discovery: on\n` : '';
   const unsigned = `# Continuity Context\n\n- Envelope Schema: [tiinex.root.v1](${envelopeTarget})\n- Current\n  - Current Schema: [tiinex.workspace.v1](${schemaTarget})\n  - Created At: ${createdAt}\n  - Authors: ${authors}\n  - Why: Establish an explicit portable Workspace entrypoint for this repository.\n  - Summary: ${title} Workspace.\n  - Status: active/local\n\n---\n\n# ${title}${entrypoint}\n# Continuity Integrity\n\n- [sha256-base64url-c14n-v2](${integrityTarget})\n  - Towards: self\n  - Value: pending\n`;
   const sealed = sealC14nV2Self(unsigned);
   if (sealed.state !== 'sealed') return blocked([finding('error', 'workspace.initialize.integrity-seal.failed', 'Core could not seal Workspace c14n-v2 self integrity.', { reason: sealed.reason || sealed.state })]);

package/src/transitions/record.transitions.js

@@ -169,19 +169,21 @@ export function allocateContinuationPath({ parentRecord = {}, targetId = '', tar
   const explicitPath = canonicalLocalPath(options.path || options.draftPath || '');
   if (explicitPath) return { path: uniqueTransitionPath(explicitPath, occupied), policy: pathPolicyForExplicit(explicitPath) };
   const parentPath = externalWebArtifactUrl(parentRecord) ? '' : canonicalLocalPath(parentRecord.path || parentRecord.sourcePath || parentRecord.sourceTarget?.sourceArtifactPath || '');
-  const parentDir = parentDirectory(parentPath) || '.topics';
-  const requestedDir = canonicalLocalPath(options.targetDirectory || options.directory || '');
-  const targetDir = requestedDir || parentDir;
+  const parentDir = parentDirectory(parentPath);
+  const requestedRaw = String(options.targetDirectory || options.directory || '').trim();
+  const requestedExplicit = Boolean(requestedRaw);
+  const requestedDir = requestedRaw === '.' ? '' : canonicalLocalPath(requestedRaw);
+  const targetDir = requestedExplicit ? requestedDir : (parentDir || '.topics');
   const parentPrefix = lineagePrefixFromPath(parentPath);
   const labelSlug = slugify(title || parentRecord.title || targetLabel || 'continuation');
   const targetSlug = slugify(targetLabel || labelFromSchemaId(targetId) || 'leaf');
   const extension = '.trace.md';
-  const directoryLocal = Boolean(requestedDir && requestedDir !== parentDir);
+  const directoryLocal = Boolean(requestedExplicit && requestedDir !== parentDir);
   const policy = {
     schema: 'tiinex.transition.path-policy.v1',
     kind: directoryLocal ? 'directory-local-continuation' : 'same-parent-directory',
     parentDirectory: parentDir,
-    targetDirectory: targetDir,
+    targetDirectory: requestedExplicit && requestedDir === '' ? '.' : targetDir,
     parentPath,
     parentLineagePrefix: parentPrefix,
     labelSlug,
@@ -196,14 +198,16 @@ export function allocateDirectoryArtifactPath({ targetDirectory = '.topics', tar
   const occupied = existingTransitionPaths(options);
   const explicitPath = canonicalLocalPath(options.path || options.draftPath || '');
   if (explicitPath) return { path: uniqueTransitionPath(explicitPath, occupied), policy: pathPolicyForExplicit(explicitPath) };
-  const dir = canonicalLocalPath(targetDirectory || '.topics') || '.topics';
+  const targetRaw = String(targetDirectory ?? '').trim();
+  const explicitRoot = targetRaw === '.';
+  const dir = explicitRoot ? '' : (canonicalLocalPath(targetRaw || '.topics') || '.topics');
   const labelSlug = slugify(title || targetLabel || labelFromSchemaId(targetId) || 'artifact');
   const targetSlug = slugify(targetLabel || labelFromSchemaId(targetId) || 'artifact');
   const extension = '.trace.md';
   const policy = {
     schema: 'tiinex.transition.path-policy.v1',
     kind: 'directory-local-root',
-    targetDirectory: dir,
+    targetDirectory: explicitRoot ? '.' : dir,
     labelSlug,
     targetSlug,
     extension,
@@ -214,20 +218,25 @@ export function allocateDirectoryArtifactPath({ targetDirectory = '.topics', tar
 
 function pathFromPolicy(policy = {}, occupied = new Set()) {
   const kind = String(policy.kind || '').trim();
-  const dir = canonicalLocalPath(policy.targetDirectory || policy.parentDirectory || '.topics') || '.topics';
+  const hasTargetDirectory = Object.prototype.hasOwnProperty.call(policy, 'targetDirectory');
+  const hasParentDirectory = Object.prototype.hasOwnProperty.call(policy, 'parentDirectory');
+  const rawDirectory = hasTargetDirectory ? String(policy.targetDirectory ?? '') : hasParentDirectory ? String(policy.parentDirectory ?? '') : '.topics';
+  const rootDirectory = rawDirectory === '.' || ((hasTargetDirectory || hasParentDirectory) && rawDirectory === '');
+  const dir = rootDirectory ? '' : (canonicalLocalPath(rawDirectory || '.topics') || '.topics');
+  const pathPrefix = dir ? `${dir}/` : '';
   const extension = String(policy.extension || '.trace.md').startsWith('.') ? String(policy.extension || '.trace.md') : `.${policy.extension}`;
   const labelSlug = slugify(policy.labelSlug || 'continuation');
   const targetSlug = slugify(policy.targetSlug || 'leaf');
   const parentPrefix = String(policy.parentLineagePrefix || '').trim();
   if (kind === 'directory-local-root' || kind === 'directory-local-continuation') {
     const rootPrefix = nextDirectoryRootLineagePrefix(dir, occupied);
-    return `${dir}/${rootPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
+    return `${pathPrefix}${rootPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
   }
   if (parentPrefix) {
     const childPrefix = nextChildLineagePrefix(parentPrefix, dir, occupied);
-    return `${dir}/${childPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
+    return `${pathPrefix}${childPrefix}-${labelSlug}.${extension.replace(/^\./, '')}`;
   }
-  return uniqueTransitionPath(`${dir}/${labelSlug}--${targetSlug}${extension}`, occupied);
+  return uniqueTransitionPath(`${pathPrefix}${labelSlug}--${targetSlug}${extension}`, occupied);
 }
 
 function pathPolicyForExplicit(path = '') {