@toolproof-core/lib 1.0.34 → 1.0.37

package/src/utils/bindInputRoleToResource.ts

@@ -1,54 +0,0 @@
-import type {
-    CreationContext,
-    Resource,
-    ReferenceInput,
-    ValueInput,
-} from '@toolproof-core/schema';
-import {
-    clearStrategyStateEntry,
-    getStrategyStateEntry,
-    setStrategyStateEntry,
-    type StrategyState,
-    type StrategyStateLike,
-} from './strategyState.js';
-
-
-export function bindInputResInStrategyState<TStrategyState extends StrategyStateLike>(
-    strategyState: TStrategyState,
-    target: CreationContext,
-    resource: Resource
-): TStrategyState {
-    const entry: ValueInput = {
-        strategyStateInputKind: 'valueInput',
-        resourceTypeId: resource.resourceTypeId,
-        nucleus: resource.nucleus,
-    };
-
-    return setStrategyStateEntry(strategyState, target, entry);
-}
-
-export function bindInputRefInStrategyState<TStrategyState extends StrategyStateLike>(
-    strategyState: TStrategyState,
-    target: CreationContext,
-    source: CreationContext
-): TStrategyState {
-    const sourceEntry = getStrategyStateEntry(strategyState, source);
-    if (!sourceEntry) {
-        throw new Error(`resourceEntry not found for source (${source.toolStepPath}, ${source.roleName})`);
-    }
-
-    const entry: ReferenceInput = {
-        strategyStateInputKind: 'referenceInput',
-        toolStepPath: source.toolStepPath,
-        roleName: source.roleName,
-    };
-
-    return setStrategyStateEntry(strategyState, target, entry);
-}
-
-export function clearInputBindingInStrategyState<TStrategyState extends StrategyStateLike>(
-    strategyState: TStrategyState,
-    target: CreationContext
-): TStrategyState {
-    return clearStrategyStateEntry(strategyState, target);
-}

package/src/utils/creation/resourceCreation.ts

@@ -1,121 +0,0 @@
-import type {
-    CreationContext,
-    ExternalInput,
-    ReferenceInput,
-    ResourceId,
-    Resource,
-    ResourceTypeId,
-    StrategyRunId,
-} from '@toolproof-core/schema';
-
-export interface OutputPotential {
-    id: ResourceId;
-    resourceTypeId: ResourceTypeId;
-    creationContext: CreationContext;
-    strategyRunId?: StrategyRunId;
-}
-
-export type InputPotential = ReferenceInput & {
-    id: ResourceId;
-    resourceTypeId: ResourceTypeId;
-    creationContext: CreationContext;
-    strategyRunId?: StrategyRunId;
-};
-
-export function generatePath(resourceTypeId: ResourceTypeId, id: ResourceId): string {
-    return `${resourceTypeId}/${id}.json`;
-}
-
-export function createMaterializedFromOutputPotential(
-    outputPotential: OutputPotential,
-    nucleus: unknown,
-    timestamp?: string,
-): Resource {
-    const { id, resourceTypeId, creationContext } = outputPotential;
-    const path = generatePath(resourceTypeId, id);
-
-    return {
-        id,
-        resourceTypeId,
-        provenance: {
-            resourceProvenanceKind: 'strategy',
-            strategyRunId: outputPotential.strategyRunId ?? ('STRATEGY_RUN-UNKNOWN' as StrategyRunId),
-            creationContext,
-        },
-        version: 1,
-        timestamp: timestamp ?? new Date().toISOString(),
-        path,
-        nucleus,
-    };
-}
-
-export function createMaterializedFromInputPotential(
-    inputPotential: InputPotential,
-    nucleus: unknown,
-    timestamp?: string,
-): Resource {
-    const { id, resourceTypeId, creationContext } = inputPotential;
-    const path = generatePath(resourceTypeId, id);
-
-    return {
-        id,
-        resourceTypeId,
-        provenance: {
-            resourceProvenanceKind: 'strategy',
-            strategyRunId: inputPotential.strategyRunId ?? ('STRATEGY_RUN-UNKNOWN' as StrategyRunId),
-            creationContext,
-        },
-        version: 1,
-        timestamp: timestamp ?? new Date().toISOString(),
-        path,
-        nucleus,
-    };
-}
-
-export function createMaterializedFromPotential(
-    potential: InputPotential | OutputPotential,
-    nucleus: unknown,
-    timestamp?: string,
-): Resource {
-    if ('strategyStateInputKind' in potential && potential.strategyStateInputKind === 'referenceInput') {
-        return createMaterializedFromInputPotential(potential, nucleus, timestamp);
-    }
-
-    return createMaterializedFromOutputPotential(potential, nucleus, timestamp);
-}
-
-export function createExternalInputPotential(
-    _id: ResourceId,
-    _resourceTypeId: ResourceTypeId,
-): ExternalInput {
-    return {
-        strategyStateInputKind: 'externalInput',
-    };
-}
-
-export function createInputPotential(
-    id: ResourceId,
-    resourceTypeId: ResourceTypeId,
-    creationContext: CreationContext,
-): InputPotential {
-    return {
-        id,
-        resourceTypeId,
-        strategyStateInputKind: 'referenceInput',
-        toolStepPath: creationContext.toolStepPath,
-        roleName: creationContext.roleName,
-        creationContext,
-    };
-}
-
-export function createOutputPotential(
-    id: ResourceId,
-    resourceTypeId: ResourceTypeId,
-    creationContext: CreationContext,
-): OutputPotential {
-    return {
-        id,
-        resourceTypeId,
-        creationContext,
-    };
-}

package/src/utils/creation/stepCreation.ts

@@ -1,165 +0,0 @@
-import type {
-    BranchStep,
-    Case,
-    ForStep,
-    Tool,
-    ToolStep,
-    WhileStep,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
-import { getInputRoleNames, getOutputRoleNames } from '../roleSpec.js';
-
-type ToolStepId = string;
-type BranchStepId = string;
-type ForStepId = string;
-type WhileStepId = string;
-
-type ToolStepWithId = ToolStep & { id: ToolStepId };
-type BranchStepWithId = BranchStep & { id: BranchStepId };
-type ForStepWithId = ForStep & { id: ForStepId };
-type WhileStepWithId = WhileStep & { id: WhileStepId };
-
-export type LoopStepBuildIdentities =
-    | {
-        stepKind: typeof CONSTANTS.Enums.StepKind.for;
-        stepId: ForStepId;
-        whatId: ToolStepId;
-        whenId: ToolStepId;
-    }
-    | {
-        stepKind: typeof CONSTANTS.Enums.StepKind.while;
-        stepId: WhileStepId;
-        whatId: ToolStepId;
-        whenId: ToolStepId;
-    };
-
-export type BranchCaseBuildIdentities = {
-    whatId: ToolStepId;
-    whenId: ToolStepId;
-};
-
-function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
-    if (arr.length === 0) {
-        throw new Error(msg);
-    }
-}
-
-function getRoleBindingSpec(tool: Tool): ToolStep['roleBindingSpec'] {
-    return {
-        inputBindings: getInputRoleNames(tool),
-        outputBindings: getOutputRoleNames(tool),
-    };
-}
-
-export function buildToolStepFromTool(
-    tool: Tool,
-    id: ToolStepId,
-): ToolStepWithId {
-    return {
-        id,
-        stepKind: CONSTANTS.Enums.StepKind.tool,
-        toolId: tool.id,
-        roleBindingSpec: getRoleBindingSpec(tool),
-    } as ToolStepWithId;
-}
-
-export function buildLoopStepFromToolPair(
-    whatTool: Tool,
-    whenTool: Tool,
-    identities: LoopStepBuildIdentities,
-): ForStep | WhileStep {
-    const what = buildToolStepFromTool(whatTool, identities.whatId);
-    const when = buildToolStepFromTool(whenTool, identities.whenId);
-
-    if (identities.stepKind === CONSTANTS.Enums.StepKind.for) {
-        return {
-            id: identities.stepId,
-            stepKind: CONSTANTS.Enums.StepKind.for,
-            case: { what, when },
-        } as ForStepWithId;
-    }
-
-    return {
-        id: identities.stepId,
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: { what, when },
-    } as WhileStepWithId;
-}
-
-export function buildBranchStepFromToolPairs(
-    cases: Array<{ whatTool: Tool; whenTool: Tool }>,
-    branchId: BranchStepId,
-    caseIdentities: BranchCaseBuildIdentities[],
-): BranchStepWithId {
-    if (cases.length !== caseIdentities.length) {
-        throw new Error('buildBranchStepFromToolPairs requires one id pair per case');
-    }
-
-    const resolved = cases.map(({ whatTool, whenTool }, index) => {
-        const identities = caseIdentities[index];
-
-        if (!identities) {
-            throw new Error(`Missing case identities for case index ${index}`);
-        }
-
-        const what = buildToolStepFromTool(whatTool, identities.whatId);
-        const when = buildToolStepFromTool(whenTool, identities.whenId);
-        return { what, when } satisfies Case;
-    });
-
-    assertNonEmpty(resolved, 'buildBranchStepFromToolPairs requires at least one case');
-
-    return {
-        id: branchId,
-        stepKind: CONSTANTS.Enums.StepKind.branch,
-        cases: resolved,
-    } as BranchStepWithId;
-}
-
-export function cloneForStepWithIdentities(
-    forStep: ForStep,
-    identities: {
-        stepId: ForStepId;
-        whatId: ToolStepId;
-        whenId: ToolStepId;
-    },
-): ForStepWithId {
-    return {
-        id: identities.stepId,
-        stepKind: CONSTANTS.Enums.StepKind.for,
-        case: {
-            what: {
-                ...forStep.case.what,
-                id: identities.whatId,
-            },
-            when: {
-                ...forStep.case.when,
-                id: identities.whenId,
-            },
-        },
-    } as ForStepWithId;
-}
-
-export function cloneWhileStepWithIdentities(
-    whileStep: WhileStep,
-    identities: {
-        stepId: WhileStepId;
-        whatId: ToolStepId;
-        whenId: ToolStepId;
-    },
-): WhileStepWithId {
-    return {
-        id: identities.stepId,
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: {
-            what: {
-                ...whileStep.case.what,
-                id: identities.whatId,
-            },
-            when: {
-                ...whileStep.case.when,
-                id: identities.whenId,
-            },
-        },
-    } as WhileStepWithId;
-}

package/src/utils/creation/threadedStrategyCreation.ts

@@ -1,42 +0,0 @@
-import type {
-    Step,
-    StrategyId,
-} from '@toolproof-core/schema';
-import { getIndependentThreads } from '../parallelizeSteps.js';
-import { CONSTANTS } from '../../artifacts/artifacts.js';
-
-export type ThreadableStrategy<TStrategyState = unknown> = {
-    id: StrategyId;
-    strategyState: TStrategyState;
-} & (
-    | { steps: Step[] }
-    | { stepsByThreadIndex: Step[][] }
-);
-
-export type ThreadedStrategyLike<TStrategyState = unknown> = {
-    id: StrategyId;
-    strategyKind: typeof CONSTANTS.Enums.StrategyKind.threaded;
-    stepsByThreadIndex: Step[][];
-    strategyState: TStrategyState;
-};
-
-export function getThreadedStrategyStepGroups<TStrategyState>(strategy: ThreadableStrategy<TStrategyState>): Step[][] {
-    if ('steps' in strategy) {
-        return getIndependentThreads(strategy.steps, strategy.strategyState as any);
-    }
-
-    return strategy.stepsByThreadIndex;
-}
-
-export function buildThreadedStrategy<TStrategyState>(
-    threadStepGroups: Step[][],
-    threadedStrategyId: StrategyId,
-    strategy: ThreadableStrategy<TStrategyState>,
-): ThreadedStrategyLike<TStrategyState> {
-    return {
-        id: threadedStrategyId,
-        strategyKind: CONSTANTS.Enums.StrategyKind.threaded,
-        stepsByThreadIndex: threadStepGroups,
-        strategyState: strategy.strategyState,
-    };
-}

package/src/utils/extractData.ts

@@ -1,129 +0,0 @@
-import type {
-    RoleName,
-    RoleValue,
-    ToolId,
-    Tool,
-    ToolStep,
-    ResourceId,
-    ResourceTypeId,
-    Resource,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import {
-    extractToolStepsFromStrategy,
-    getInputRoleEntries,
-    getOutputRoleEntries,
-    toToolRoleDescriptor,
-    type StrategyStepGraph,
-    type ToolRoleDescriptor,
-} from './roleSpec.js';
-
-
-export function extractToolIdsFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolId[] {
-    const toolSteps = extractToolStepsFromUnthreadedStrategy(unthreadedStrategy);
-    const ids = new Set<ToolId>();
-    for (const jStep of toolSteps) {
-        ids.add(jStep.toolId);
-    }
-    return Array.from(ids);
-}
-
-export function extractToolStepsFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph): ToolStep[] {
-    return extractToolStepsFromStrategy(unthreadedStrategy);
-}
-
-
-export function extractRoleMapFromUnthreadedStrategy(unthreadedStrategy: StrategyStepGraph, toolMap: Map<ToolId, Tool>): Map<RoleName, ToolRoleDescriptor> {
-    const roleMap = new Map<RoleName, ToolRoleDescriptor>();
-    const toolIds = extractToolIdsFromUnthreadedStrategy(unthreadedStrategy);
-
-    for (const toolId of toolIds) {
-        const tool = toolMap.get(toolId);
-        if (!tool) continue;
-
-        for (const entry of getInputRoleEntries(tool)) {
-            roleMap.set(entry[0], toToolRoleDescriptor(entry));
-        }
-        for (const entry of getOutputRoleEntries(tool)) {
-            roleMap.set(entry[0], toToolRoleDescriptor(entry));
-        }
-    }
-
-    return roleMap;
-}
-
-export function extractSingleNonErrorOutputTypeId(tool: Tool): ResourceTypeId | null {
-    const errorRoleId = CONSTANTS.Cosmos.ROLE_ErrorOutput;
-    const outputEntries = getOutputRoleEntries(tool).filter(([roleName]) => roleName !== errorRoleId);
-    if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
-        throw new Error(`Tool ${tool.id} must have exactly one non-error output role to be branchable/loopable`);
-    } // ATTENTION_PUREIFY
-    const outputRole = outputEntries[0][1] as RoleValue;
-    return outputRole.resourceTypeId;
-}
-
-
-
-export function extractResourceMapForType<TResource extends Resource = Resource>(
-    resourcesByType: Partial<Record<ResourceTypeId, TResource[]>>,
-    resourceTypeId: ResourceTypeId
-): Map<ResourceId, TResource> {
-    const resources = resourcesByType[resourceTypeId] ?? [];
-    const map = new Map<ResourceId, TResource>();
-
-    for (const resource of resources) {
-        map.set(resource.id, resource);
-    }
-
-    return map;
-}
-
-// Only use this for resource types whose nuclei are entity-like objects with their own intrinsic id.
-export function extractIdKeyedNucleusMapForType<
-    TKey extends string = string,
-    TNucleus extends { id: string | number | boolean } = { id: string | number | boolean },
-    TResource extends Resource = Resource
->(
-    resourcesByType: Partial<Record<ResourceTypeId, TResource[]>>,
-    resourceTypeId: ResourceTypeId,
-): Map<TKey, TNucleus> {
-    const resourceMap = extractResourceMapForType<TResource>(resourcesByType, resourceTypeId);
-    const out = new Map<TKey, TNucleus>();
-
-    for (const resource of resourceMap.values()) {
-        const data = (resource as any).nucleus as unknown;
-        if (data === null || data === undefined) {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeId}' to have a nucleus`
-            );
-        }
-        if (typeof data !== 'object') {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeId}' to have an object nucleus with id`
-            );
-        }
-
-        const maybeId = (data as any).id as unknown;
-        if (maybeId === null || maybeId === undefined) {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeId}' to have nucleus.id`
-            );
-        }
-        if (
-            typeof maybeId !== 'string' &&
-            typeof maybeId !== 'number' &&
-            typeof maybeId !== 'boolean'
-        ) {
-            throw new Error(
-                `Expected resource '${resource.id}' of type '${resourceTypeId}' to have nucleus.id as string, number, or boolean`
-            );
-        }
-
-        const value = data as TNucleus;
-        const key = String(maybeId) as TKey;
-
-        out.set(key, value);
-    }
-
-    return out;
-}

package/src/utils/parallelizeSteps.ts

@@ -1,187 +0,0 @@
-import type {
-    BranchStep,
-    ForStep,
-    ToolStep,
-    Step,
-    WhileStep,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import type { StrategyState } from './strategyState.js';
-
-type ToolStepId = string;
-type ToolStepWithId = ToolStep & { id: ToolStepId };
-
-function getToolStepId(toolStep: ToolStep | undefined): ToolStepId | undefined {
-    const maybeId = (toolStep as Partial<ToolStepWithId> | undefined)?.id;
-    return typeof maybeId === 'string' ? maybeId : undefined;
-}
-
-
-export function getIndependentThreads(steps: Step[], strategyState: StrategyState): Step[][] {
-    type OwnerIndex = number;
-
-    const getOwnerLabel = (ownerIndex: OwnerIndex) => {
-        const step = steps[ownerIndex];
-        return `steps[${ownerIndex}] stepKind=${(step as any)?.stepKind ?? 'unknown'}`;
-    };
-
-    // Map each toolStep.id (including macro-nested tool steps) to owning top-level step index.
-    const toolStepIdToOwner = new Map<ToolStepId, OwnerIndex>();
-    const ownerToToolStepIds = new Map<OwnerIndex, ToolStepId[]>();
-    const toolStepById = new Map<ToolStepId, ToolStepWithId>();
-
-    const addToolStep = (toolStep: ToolStep | undefined, ownerIndex: OwnerIndex) => {
-        const toolStepId = getToolStepId(toolStep);
-        if (!toolStepId || !toolStep) return;
-
-        const existingOwner = toolStepIdToOwner.get(toolStepId);
-        if (existingOwner !== undefined) {
-            throw new Error(
-                `Duplicate toolStep.id '${toolStepId}' found in ${getOwnerLabel(ownerIndex)} and ${getOwnerLabel(existingOwner)}`
-            );
-        }
-
-        toolStepIdToOwner.set(toolStepId, ownerIndex);
-        toolStepById.set(toolStepId, toolStep as ToolStepWithId);
-        const bucket = ownerToToolStepIds.get(ownerIndex) ?? [];
-        bucket.push(toolStepId);
-        ownerToToolStepIds.set(ownerIndex, bucket);
-    };
-
-    steps.forEach((step, ownerIndex) => {
-        if (step.stepKind === CONSTANTS.Enums.StepKind.tool) {
-            addToolStep(step as ToolStep, ownerIndex);
-            return;
-        }
-
-        if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
-            const loop = step as ForStep;
-            addToolStep(loop.case?.what, ownerIndex);
-            addToolStep(loop.case?.when, ownerIndex);
-            return;
-        }
-
-        if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
-            const loop = step as WhileStep;
-            addToolStep(loop.case?.what, ownerIndex);
-            addToolStep(loop.case?.when, ownerIndex);
-            return;
-        }
-
-        if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
-            const branch = step as BranchStep;
-            for (const caseItem of branch.cases ?? []) {
-                addToolStep(caseItem?.what, ownerIndex);
-                addToolStep(caseItem?.when, ownerIndex);
-            }
-            return;
-        }
-    });
-
-    // Undirected adjacency used for connected components (thread groups).
-    const ownerAdj = new Map<OwnerIndex, Set<OwnerIndex>>();
-    // Directed dependencies used for strict ordering validation: owner -> producers it depends on.
-    const ownerDeps = new Map<OwnerIndex, Set<OwnerIndex>>();
-
-    const ensureOwner = (ownerIndex: OwnerIndex) => {
-        if (!ownerAdj.has(ownerIndex)) ownerAdj.set(ownerIndex, new Set());
-        if (!ownerDeps.has(ownerIndex)) ownerDeps.set(ownerIndex, new Set());
-    };
-
-    for (let i = 0; i < steps.length; i++) {
-        ensureOwner(i);
-    }
-
-    // Discover dependencies from strategyState.
-    for (const [toolStepId, ownerIndex] of toolStepIdToOwner) {
-        ensureOwner(ownerIndex);
-
-        const toolStep = toolStepById.get(toolStepId);
-        const inputBindings = toolStep?.roleBindingSpec?.inputBindings ?? [];
-        const bucket = strategyState?.[toolStepId] ?? ({} as any);
-
-        for (const inputRoleId of inputBindings) {
-            const entry = bucket?.[inputRoleId] as any;
-            if (!entry || entry.strategyStateInputKind !== 'referenceInput') continue;
-
-            const creatorToolStepId = typeof entry?.toolStepPath === 'string'
-                ? entry.toolStepPath as ToolStepId
-                : undefined;
-            if (!creatorToolStepId) {
-                throw new Error(
-                    `Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): missing toolStepPath for role '${inputRoleId}'`
-                );
-            }
-
-            const producerOwner = toolStepIdToOwner.get(creatorToolStepId);
-            if (producerOwner === undefined) {
-                throw new Error(
-                    `Unresolvable referenceInput in toolStep '${toolStepId}' (${getOwnerLabel(ownerIndex)}): creator toolStepPath '${creatorToolStepId}' not found in strategy steps`
-                );
-            }
-
-            ensureOwner(producerOwner);
-            ownerAdj.get(ownerIndex)!.add(producerOwner);
-            ownerAdj.get(producerOwner)!.add(ownerIndex);
-            ownerDeps.get(ownerIndex)!.add(producerOwner);
-        }
-    }
-
-    // Connected components over owners.
-    const visited = new Set<OwnerIndex>();
-    const components: OwnerIndex[][] = [];
-
-    for (let ownerIndex = 0; ownerIndex < steps.length; ownerIndex++) {
-        if (visited.has(ownerIndex)) continue;
-        const component: OwnerIndex[] = [];
-        const queue: OwnerIndex[] = [ownerIndex];
-        visited.add(ownerIndex);
-        while (queue.length > 0) {
-            const node = queue.shift()!;
-            component.push(node);
-            for (const neighbor of ownerAdj.get(node) ?? []) {
-                if (!visited.has(neighbor)) {
-                    visited.add(neighbor);
-                    queue.push(neighbor);
-                }
-            }
-        }
-        components.push(component);
-    }
-
-    // Strict validation: within a thread, the linear order must not contain forward refs.
-    for (const comp of components) {
-        const compSet = new Set(comp);
-        const ownersInOrder = steps.map((_, i) => i).filter((i) => compSet.has(i));
-
-        const position = new Map<OwnerIndex, number>();
-        ownersInOrder.forEach((owner, idx) => position.set(owner, idx));
-
-        for (const consumerOwner of ownersInOrder) {
-            const deps = ownerDeps.get(consumerOwner);
-            if (!deps || deps.size === 0) continue;
-
-            const consumerPos = position.get(consumerOwner)!;
-            for (const producerOwner of deps) {
-                const producerPos = position.get(producerOwner);
-                if (producerPos === undefined) {
-                    throw new Error(
-                        `Internal error: dependency producer ${getOwnerLabel(producerOwner)} missing from computed thread for ${getOwnerLabel(consumerOwner)}`
-                    );
-                }
-                if (producerPos >= consumerPos) {
-                    throw new Error(
-                        `Invalid step order in thread: ${getOwnerLabel(consumerOwner)} depends on ${getOwnerLabel(producerOwner)}, but producer is not scheduled before consumer`
-                    );
-                }
-            }
-        }
-    }
-
-    return components
-        .map((compOwners) => {
-            const ownerSet = new Set(compOwners);
-            return steps.filter((_, i) => ownerSet.has(i));
-        })
-        .filter((group) => group.length > 0);
-}