@shapeshift-labs/frontier-swarm 0.5.22 → 0.5.23

package/dist/index.js

@@ -1,4 +1,5 @@
 import { createRunDashboardSnapshot, createRunEdgeEvent, createRunEvent, createRunNodeEvent, defineRunArtifact, defineRunAttempt, defineRunDecision, defineRunEvidence, defineRunLane, defineRunPatch, defineRunTask, defineRunVerification, linkRunNodes, replayRunEvents } from '@shapeshift-labs/frontier-run';
+import { acquireSemanticLease, createSemanticLeaseState, defineSemanticLeaseScope, validateSemanticLeaseFence } from '@shapeshift-labs/frontier-lease';
 export const FRONTIER_SWARM_MANIFEST_KIND = 'frontier.swarm.manifest';
 export const FRONTIER_SWARM_MANIFEST_VERSION = 1;
 export const FRONTIER_SWARM_TASK_KIND = 'frontier.swarm.task';
@@ -4075,6 +4076,11 @@ export function createSwarmHierarchicalMergeQueue(input) {
     const admissionPressure = summarizeSwarmMergeAdmissionPressure(assignments);
     const orderedScopes = Array.from(scopes.values()).sort((left, right) => (mergeQueueScopeRank(left.kind) - mergeQueueScopeRank(right.kind)
         || left.id.localeCompare(right.id)));
+    const semanticLeaseScopeMap = createSwarmSemanticLeaseScopeMap(orderedScopes, {
+        rootScopeId,
+        ...semanticLeaseScopeOptionsFromMetadata(input.metadata)
+    });
+    const scopesWithSemanticLeases = orderedScopes.map((scope) => attachSemanticLeaseScopeToMergeQueueScope(scope, semanticLeaseScopeMap));
     const queueId = input.id ?? 'swarm-hierarchical-merge-queue:' + stableHash([input.index.id, input.admission?.id, orderedScopes, assignments, promotions, generatedAt]);
     const linkedAssignments = assignments.map((assignment) => {
         if (!coordinatorAgentDrainActionIsTerminal(assignment.action))
@@ -4084,19 +4090,19 @@ export function createSwarmHierarchicalMergeQueue(input) {
             terminalDecisionId: hierarchicalQueueTerminalDecisionId(queueId, assignment),
             terminalDecisionQueueItemIds: [...assignment.queueItemIds]
         };
-    });
+    }).map((assignment) => attachSemanticLeaseScopesToAssignment(assignment, semanticLeaseScopeMap));
     const leaseRecords = createHierarchicalQueueLeaseRecords({
         queueId,
         rootScopeId,
         generatedAt,
-        scopes: orderedScopes,
+        scopes: scopesWithSemanticLeases,
         assignments: linkedAssignments,
         promotions,
         localLeader: input.localLeader,
         localLeaders: input.localLeaders
     });
     const byLeaseKey = groupJobIdsByMany(linkedAssignments, (assignment) => assignment.requiredLeaseKeys ?? [assignment.leaseKey]);
-    const scopeTree = createHierarchicalQueueScopeTree(orderedScopes, rootScopeId);
+    const scopeTree = createHierarchicalQueueScopeTree(scopesWithSemanticLeases, rootScopeId);
     return {
         kind: FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_KIND,
         version: FRONTIER_SWARM_HIERARCHICAL_MERGE_QUEUE_VERSION,
@@ -4106,13 +4112,14 @@ export function createSwarmHierarchicalMergeQueue(input) {
         generatedAt,
         rootScopeId,
         scopeTree,
-        scopes: orderedScopes,
+        scopes: scopesWithSemanticLeases,
         leaseRecords,
         assignments: linkedAssignments,
         promotions,
         byScope,
         byLeaseKey,
         byAction,
+        semanticLeaseScopes: uniqueSemanticLeaseScopes(Array.from(semanticLeaseScopeMap.values())),
         summary: {
             scopeCount: orderedScopes.length,
             assignmentCount: linkedAssignments.length,
@@ -4142,6 +4149,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
             title: scope.title,
             leaseScope: scope.leaseKey,
             leaseKey: scope.leaseKey,
+            ...(scope.semanticLeaseScope ? { semanticLeaseScope: scope.semanticLeaseScope } : {}),
             ...(scope.parentId ? { parentQueueId: scope.parentId } : {}),
             ...(scope.lane ? { lane: scope.lane } : {}),
             changedPaths: [...scope.changedPaths],
@@ -4171,6 +4179,9 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         const requiredLeaseKeys = assignmentRequiredLeaseKeys.length
             ? [...assignmentRequiredLeaseKeys]
             : [leaseScope];
+        const requiredSemanticLeaseScopes = requiredLeaseScopeIds
+            .map((scopeId) => scopesById.get(scopeId)?.semanticLeaseScope)
+            .filter((scope) => Boolean(scope));
         const decision = coordinatorAgentDrainDecisionForAction(assignment.action);
         const terminal = coordinatorAgentDrainActionIsTerminal(assignment.action);
         const parentQueueId = assignment.action === 'promote'
@@ -4207,6 +4218,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
             conflictingJobIds: [...assignment.conflictingJobIds],
             requiredLeaseScopeIds,
             requiredLeaseKeys,
+            ...(requiredSemanticLeaseScopes.length ? { requiredSemanticLeaseScopes } : {}),
             ...(assignment.retrySlices?.length ? { retrySlices: cloneMergeQueueRetrySlices(assignment.retrySlices) } : {}),
             ...(assignment.semanticSliceScopeIds?.length ? { semanticSliceScopeIds: [...assignment.semanticSliceScopeIds] } : {}),
             ...(assignment.semanticSliceLeaseKeys?.length ? { semanticSliceLeaseKeys: [...assignment.semanticSliceLeaseKeys] } : {}),
@@ -4231,6 +4243,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         reasons: [...assignment.reasons],
         requiredLeaseScopeIds: [...(assignment.requiredLeaseScopeIds ?? [])],
         requiredLeaseKeys: [...(assignment.requiredLeaseKeys ?? [])],
+        ...(assignment.requiredSemanticLeaseScopes?.length ? { requiredSemanticLeaseScopes: assignment.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope) } : {}),
         ...(assignment.retrySlices?.length ? { retrySlices: cloneMergeQueueRetrySlices(assignment.retrySlices) } : {}),
         ...(assignment.semanticSliceScopeIds?.length ? { semanticSliceScopeIds: [...assignment.semanticSliceScopeIds] } : {}),
         ...(assignment.semanticSliceLeaseKeys?.length ? { semanticSliceLeaseKeys: [...assignment.semanticSliceLeaseKeys] } : {}),
@@ -4257,6 +4270,7 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         reasons: [...assignment.reasons],
         requiredLeaseScopeIds: [...(assignment.requiredLeaseScopeIds ?? [])],
         requiredLeaseKeys: [...(assignment.requiredLeaseKeys ?? [])],
+        ...(assignment.requiredSemanticLeaseScopes?.length ? { requiredSemanticLeaseScopes: assignment.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope) } : {}),
         ...(assignment.metadata ? { metadata: cloneJsonValue(assignment.metadata) } : {})
     }));
     const activeAssignments = assignments.filter((assignment) => !coordinatorAgentDrainAssignmentIsTerminal(assignment));
@@ -4314,6 +4328,120 @@ export function createSwarmCoordinatorAgentDrainWork(input) {
         ...(toJsonObject(input.metadata) ? { metadata: toJsonObject(input.metadata) } : {})
     };
 }
+export function createSwarmSemanticLeaseScopeForMergeQueueScope(scope, input = {}) {
+    const scopesById = new Map((input.scopes ?? []).map((entry) => [entry.id, entry]));
+    const parentKeys = [];
+    let parentId = scope.parentId;
+    const visited = new Set([scope.id]);
+    while (parentId && !visited.has(parentId)) {
+        const parent = scopesById.get(parentId);
+        if (!parent)
+            break;
+        parentKeys.push(parent.leaseKey);
+        visited.add(parentId);
+        parentId = parent.parentId;
+    }
+    const regionId = scope.changedRegions.length === 1 ? scope.changedRegions[0] : scope.id;
+    const path = scope.changedPaths.length === 1 ? scope.changedPaths[0] : undefined;
+    const metadata = mergeSwarmMetadata([
+        scope.metadata,
+        toJsonObject(input.metadata),
+        {
+            swarmQueueScopeId: scope.id,
+            swarmQueueScopeKind: scope.kind,
+            swarmLeaseKey: scope.leaseKey,
+            changedPaths: scope.changedPaths,
+            changedRegions: scope.changedRegions
+        }
+    ]);
+    return defineSemanticLeaseScope({
+        kind: semanticLeaseScopeKindForMergeQueueScope(scope),
+        key: scope.leaseKey,
+        repository: input.repository,
+        packageId: input.packageId,
+        lane: scope.lane,
+        path,
+        regionId,
+        name: semanticLeaseScopeNameForMergeQueueScope(scope),
+        parentKeys,
+        metadata
+    });
+}
+export function createSwarmSemanticLeaseScopesForMergeQueue(queue, input = {}) {
+    const existing = queue.scopes
+        .map((scope) => scope.semanticLeaseScope)
+        .filter((scope) => Boolean(scope));
+    if (existing.length)
+        return uniqueSemanticLeaseScopes(existing);
+    return uniqueSemanticLeaseScopes(queue.scopes.map((scope) => (createSwarmSemanticLeaseScopeForMergeQueueScope(scope, {
+        ...input,
+        rootScopeId: input.rootScopeId ?? queue.rootScopeId,
+        scopes: queue.scopes
+    }))));
+}
+export function createSwarmSemanticLeaseStateForMergeQueue(queue, input = {}) {
+    const semanticLeaseScopes = createSwarmSemanticLeaseScopesForMergeQueue(queue, input);
+    return createSemanticLeaseState({
+        id: input.id ?? `frontier-swarm-merge-queue:${queue.id}`,
+        defaultTtlMs: input.defaultTtlMs,
+        metadata: mergeSwarmMetadata([
+            toJsonObject(input.metadata),
+            {
+                swarmQueueId: queue.id,
+                swarmMergeIndexId: queue.mergeIndexId,
+                rootScopeId: queue.rootScopeId,
+                semanticLeaseScopeCount: semanticLeaseScopes.length,
+                generatedAt: input.now ?? queue.generatedAt
+            }
+        ])
+    });
+}
+export function acquireSwarmCoordinatorSemanticLease(input) {
+    const scopes = semanticLeaseScopesForCoordinatorAssignment(input.queue, input.assignment, input);
+    const requiredLeaseScopeIds = coordinatorAssignmentRequiredLeaseScopeIds(input.assignment);
+    const requiredLeaseKeys = coordinatorAssignmentRequiredLeaseKeys(input.assignment, scopes);
+    const state = input.state ?? createSwarmSemanticLeaseStateForMergeQueue(input.queue, input);
+    const acquireInput = {
+        ownerId: input.ownerId,
+        holderId: input.holderId,
+        now: input.now,
+        ttlMs: input.ttlMs,
+        purpose: input.purpose ?? `frontier swarm coordinator apply: ${input.assignment.jobId}`,
+        reason: input.reason,
+        scopes,
+        metadata: mergeSwarmMetadata([
+            toJsonObject(input.metadata),
+            {
+                swarmQueueId: input.queue.id,
+                swarmJobId: input.assignment.jobId,
+                swarmTaskId: input.assignment.taskId,
+                requiredLeaseScopeIds,
+                requiredLeaseKeys
+            }
+        ])
+    };
+    const mutation = acquireSemanticLease(state, acquireInput);
+    return {
+        state: mutation.state,
+        mutation,
+        scopes,
+        requiredLeaseScopeIds,
+        requiredLeaseKeys,
+        ...(mutation.lease ? { lease: mutation.lease } : {})
+    };
+}
+export function validateSwarmCoordinatorSemanticLeaseFence(input) {
+    const requiredScopes = input.requiredSemanticLeaseScopes?.length
+        ? input.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope)
+        : (input.assignment.requiredSemanticLeaseScopes ?? []).map(cloneSemanticLeaseScope);
+    return validateSemanticLeaseFence(input.state, {
+        leaseId: input.leaseId ?? input.lease?.id ?? '',
+        token: input.token,
+        fencingToken: input.fencingToken,
+        now: input.now,
+        scopes: requiredScopes.length ? requiredScopes : undefined
+    });
+}
 export function summarizeSwarmCoordinatorAgentDrainWork(work) {
     const activeAssignments = work.assignments.filter((assignment) => !coordinatorAgentDrainAssignmentIsTerminal(assignment));
     const terminalAssignments = work.assignments.filter((assignment) => coordinatorAgentDrainAssignmentIsTerminal(assignment));
@@ -5888,6 +6016,154 @@ function ensureMergeQueueScope(scopes, input) {
     scopes.set(scope.id, scope);
     return scope;
 }
+function createSwarmSemanticLeaseScopeMap(scopes, input = {}) {
+    const out = new Map();
+    for (const scope of scopes) {
+        out.set(scope.id, createSwarmSemanticLeaseScopeForMergeQueueScope(scope, { ...input, scopes }));
+    }
+    return out;
+}
+function attachSemanticLeaseScopeToMergeQueueScope(scope, semanticLeaseScopes) {
+    const semanticLeaseScope = semanticLeaseScopes.get(scope.id);
+    return {
+        ...scope,
+        ...(semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(semanticLeaseScope) } : {})
+    };
+}
+function attachSemanticLeaseScopesToAssignment(assignment, semanticLeaseScopes) {
+    const requiredLeaseScopeIds = assignment.requiredLeaseScopeIds?.length ? assignment.requiredLeaseScopeIds : [assignment.scopeId];
+    const requiredSemanticLeaseScopes = requiredLeaseScopeIds
+        .map((scopeId) => semanticLeaseScopes.get(scopeId))
+        .filter((scope) => Boolean(scope))
+        .map(cloneSemanticLeaseScope);
+    const retrySlices = assignment.retrySlices?.map((slice) => {
+        const requiredScopeIds = slice.requiredLeaseScopeIds?.length ? slice.requiredLeaseScopeIds : [slice.scopeId];
+        const requiredScopes = requiredScopeIds
+            .map((scopeId) => semanticLeaseScopes.get(scopeId))
+            .filter((scope) => Boolean(scope))
+            .map(cloneSemanticLeaseScope);
+        const semanticLeaseScope = semanticLeaseScopes.get(slice.scopeId);
+        return {
+            ...slice,
+            ...(semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(semanticLeaseScope) } : {}),
+            ...(requiredScopes.length ? { requiredSemanticLeaseScopes: requiredScopes } : {})
+        };
+    });
+    return {
+        ...assignment,
+        ...(requiredSemanticLeaseScopes.length ? { requiredSemanticLeaseScopes } : {}),
+        ...(retrySlices?.length ? { retrySlices } : {})
+    };
+}
+function semanticLeaseScopesForCoordinatorAssignment(queue, assignment, input = {}) {
+    if (assignment.requiredSemanticLeaseScopes?.length) {
+        return uniqueSemanticLeaseScopes(assignment.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope));
+    }
+    const queueScopes = new Map(queue.scopes.map((scope) => [scope.id, scope]));
+    const semanticByKey = new Map(createSwarmSemanticLeaseScopesForMergeQueue(queue, input).map((scope) => [scope.key, scope]));
+    const fromIds = coordinatorAssignmentRequiredLeaseScopeIds(assignment)
+        .map((scopeId) => queueScopes.get(scopeId)?.semanticLeaseScope)
+        .filter((scope) => Boolean(scope));
+    if (fromIds.length)
+        return uniqueSemanticLeaseScopes(fromIds);
+    const fromKeys = coordinatorAssignmentRequiredLeaseKeys(assignment, [])
+        .map((key) => semanticByKey.get(key))
+        .filter((scope) => Boolean(scope));
+    if (fromKeys.length)
+        return uniqueSemanticLeaseScopes(fromKeys);
+    const fallbackKey = 'leaseScope' in assignment ? assignment.leaseScope : assignment.leaseKey;
+    return [defineSemanticLeaseScope({
+            kind: 'custom',
+            key: fallbackKey,
+            repository: input.repository,
+            packageId: input.packageId,
+            metadata: mergeSwarmMetadata([
+                toJsonObject(input.metadata),
+                {
+                    swarmQueueId: queue.id,
+                    swarmJobId: assignment.jobId,
+                    fallbackLeaseKey: fallbackKey
+                }
+            ])
+        })];
+}
+function coordinatorAssignmentRequiredLeaseScopeIds(assignment) {
+    const explicit = assignment.requiredLeaseScopeIds ?? [];
+    if (explicit.length)
+        return uniqueStrings(explicit);
+    return uniqueStrings(['queueId' in assignment ? assignment.queueId : assignment.scopeId]);
+}
+function coordinatorAssignmentRequiredLeaseKeys(assignment, scopes) {
+    const explicit = assignment.requiredLeaseKeys ?? [];
+    if (explicit.length)
+        return uniqueStrings(explicit);
+    if (scopes.length)
+        return uniqueStrings(scopes.map((scope) => scope.key));
+    return uniqueStrings(['leaseScope' in assignment ? assignment.leaseScope : assignment.leaseKey]);
+}
+function semanticLeaseScopeOptionsFromMetadata(metadata) {
+    const object = toJsonObject(metadata);
+    if (!object)
+        return {};
+    return {
+        ...(typeof object.repository === 'string' ? { repository: object.repository } : {}),
+        ...(typeof object.packageId === 'string' ? { packageId: object.packageId } : {})
+    };
+}
+function semanticLeaseScopeKindForMergeQueueScope(scope) {
+    if (scope.kind === 'root')
+        return 'repository';
+    if (scope.kind === 'path')
+        return 'path';
+    if (scope.kind === 'lane')
+        return 'lane';
+    if (scope.kind === 'semantic-region' || scope.kind === 'semantic')
+        return semanticLeaseScopeKindForRegion(scope.changedRegions[0]);
+    if (scope.kind === 'package')
+        return 'package';
+    return 'custom';
+}
+function semanticLeaseScopeKindForRegion(region) {
+    if (!region)
+        return 'semantic-region';
+    const normalized = region.toLowerCase();
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_EXPORT_STABLE_KEY_KIND) || normalized.includes('named-export') || normalized.includes('default-export'))
+        return 'export';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_TYPE_STABLE_KEY_KIND) || normalized.includes('interface') || normalized.includes('type-alias'))
+        return 'type';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_CLI_COMMAND_STABLE_KEY_KIND))
+        return 'cli-command';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_DOCS_SECTION_STABLE_KEY_KIND))
+        return 'docs-section';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_FIXTURE_FAMILY_STABLE_KEY_KIND))
+        return 'test-fixture';
+    if (normalized.includes(FRONTIER_SWARM_SEMANTIC_OWNERSHIP_TEST_CASE_STABLE_KEY_KIND))
+        return 'test-fixture';
+    if (normalized.includes('function'))
+        return 'function';
+    if (normalized.includes('class'))
+        return 'class';
+    if (normalized.includes('member'))
+        return 'member';
+    return 'semantic-region';
+}
+function semanticLeaseScopeNameForMergeQueueScope(scope) {
+    const region = scope.changedRegions[0];
+    if (region)
+        return region.split(':').filter(Boolean).at(-1);
+    if (scope.changedPaths.length === 1)
+        return scope.changedPaths[0].split('/').at(-1);
+    return scope.title || scope.id;
+}
+function uniqueSemanticLeaseScopes(scopes) {
+    const out = new Map();
+    for (const scope of scopes)
+        out.set(scope.key, cloneSemanticLeaseScope(scope));
+    return Array.from(out.values()).sort((left, right) => left.key.localeCompare(right.key));
+}
+function cloneSemanticLeaseScope(scope) {
+    return cloneJsonValue(scope);
+}
 function mergeQueueRootLeaseKey(rootScopeId) {
     return `merge:root:${rootScopeId}`;
 }
@@ -6002,6 +6278,8 @@ function cloneMergeQueueRetrySlices(slices) {
         leaseKey: slice.leaseKey,
         ...(slice.requiredLeaseScopeIds?.length ? { requiredLeaseScopeIds: [...slice.requiredLeaseScopeIds] } : {}),
         ...(slice.requiredLeaseKeys?.length ? { requiredLeaseKeys: [...slice.requiredLeaseKeys] } : {}),
+        ...(slice.semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(slice.semanticLeaseScope) } : {}),
+        ...(slice.requiredSemanticLeaseScopes?.length ? { requiredSemanticLeaseScopes: slice.requiredSemanticLeaseScopes.map(cloneSemanticLeaseScope) } : {}),
         ...(slice.lane ? { lane: slice.lane } : {}),
         changedPaths: [...slice.changedPaths],
         changedRegions: [...slice.changedRegions],
@@ -6051,6 +6329,7 @@ function createHierarchicalQueueLeaseRecords(input) {
             ...(scope.lane ? { lane: scope.lane } : {}),
             title: scope.title,
             leaseKey: scope.leaseKey,
+            ...(scope.semanticLeaseScope ? { semanticLeaseScope: cloneSemanticLeaseScope(scope.semanticLeaseScope) } : {}),
             ...(hierarchicalQueueLocalLeaderForScope(input, scope) ? { localLeader: hierarchicalQueueLocalLeaderForScope(input, scope) } : {}),
             promotion: {
                 state: promotionState,