@rikaidev/yomi 0.5.0 → 0.6.0

package/dist/mcp/names.js

@@ -12,6 +12,20 @@
  * process lifetime. Unresolvable MIDs are never given a fabricated
  * placeholder — callers get `null` and may fall back to the raw MID.
  */
+/**
+ * The name the authenticated user sees for a contact in the LINE app.
+ *
+ * LINE lets users rename friends locally; getContacts returns that name as
+ * `displayNameOverridden` alongside the friend's own `displayName`. The LINE
+ * app shows the override when present, so Yomi should too — otherwise names
+ * an agent reports don't match what the user sees.
+ *
+ * @param contact - Normalized contact from getContacts (may be null).
+ * @returns The user-set name, else the friend's own display name, else null.
+ */
+export function contactDisplayName(contact) {
+    return contact?.displayNameOverridden || contact?.displayName || null;
+}
 /**
  * Resolve display names for LINE user (contact) MIDs.
  *
@@ -35,9 +49,10 @@ export async function resolveUserNames(service, mids) {
     if (missing.length > 0) {
         const contacts = await service.client.getContacts(missing);
         for (const contact of contacts) {
-            if (contact?.mid && contact.displayName) {
-                service.nameCache.set(contact.mid, contact.displayName);
-                resolved.set(contact.mid, contact.displayName);
+            const name = contactDisplayName(contact);
+            if (contact?.mid && name) {
+                service.nameCache.set(contact.mid, name);
+                resolved.set(contact.mid, name);
             }
         }
     }
@@ -106,6 +121,59 @@ async function resolveGroupNames(service, chatIds) {
     }
     return resolved;
 }
+function mentionedUserMids(metadata) {
+    try {
+        const value = typeof metadata?.MENTION === 'string'
+            ? JSON.parse(metadata.MENTION)
+            : metadata?.MENTION;
+        const mentions = value?.MENTIONEES ?? value?.MENTIONS ?? [];
+        return mentions
+            .map((item) => item?.M ?? item?.mid)
+            .filter((mid) => typeof mid === 'string' && mid.startsWith('u'));
+    }
+    catch {
+        return [];
+    }
+}
+/** Legacy rooms have no chatName; LINE presents their participant names. */
+async function resolveRoomNames(service, roomIds) {
+    const resolved = new Map();
+    await Promise.all(Array.from(new Set(roomIds.filter(Boolean))).map(async (roomId) => {
+        const cached = service.chatCache.get(roomId);
+        if (cached?.chatName) {
+            resolved.set(roomId, cached.chatName);
+            return;
+        }
+        try {
+            const messages = await service.getRecentMessages(roomId, 50);
+            const selfMid = service.profile?.mid;
+            const participantMids = Array.from(new Set(messages
+                .flatMap((message) => [
+                message.from,
+                ...mentionedUserMids(message.contentMetadata),
+            ])
+                .filter((mid) => typeof mid === 'string' &&
+                mid.startsWith('u') &&
+                mid !== selfMid)));
+            const names = await resolveUserNames(service, participantMids);
+            const title = participantMids
+                .map((mid) => names.get(mid))
+                .filter((name) => Boolean(name))
+                .slice(0, 4)
+                .join('、');
+            if (!title)
+                return;
+            resolved.set(roomId, title);
+            service.chatCache.set(roomId, {
+                ...(cached ?? {}),
+                chatMid: roomId,
+                chatName: title,
+            });
+        }
+        catch { }
+    }));
+    return resolved;
+}
 /**
  * Resolve a human-readable name for each conversation id, dispatching by
  * LINE's MID prefix convention (u = 1:1 user, c = group, r = room).
@@ -116,18 +184,22 @@ async function resolveGroupNames(service, chatIds) {
  */
 export async function resolveConversationNames(service, chatIds) {
     const userIds = chatIds.filter((id) => id?.startsWith('u'));
-    const groupIds = chatIds.filter((id) => id?.startsWith('c') || id?.startsWith('r'));
-    const [userNames, groupNames] = await Promise.all([
+    const groupIds = chatIds.filter((id) => id?.startsWith('c'));
+    const roomIds = chatIds.filter((id) => id?.startsWith('r'));
+    const [userNames, groupNames, roomNames] = await Promise.all([
         userIds.length > 0
             ? resolveUserNames(service, userIds)
             : Promise.resolve(new Map()),
         groupIds.length > 0
             ? resolveGroupNames(service, groupIds)
             : Promise.resolve(new Map()),
+        roomIds.length > 0
+            ? resolveRoomNames(service, roomIds)
+            : Promise.resolve(new Map()),
     ]);
     const result = new Map();
     for (const id of chatIds) {
-        result.set(id, userNames.get(id) ?? groupNames.get(id) ?? null);
+        result.set(id, userNames.get(id) ?? groupNames.get(id) ?? roomNames.get(id) ?? null);
     }
     return result;
 }

package/dist/search/default-embedder.js

@@ -22,6 +22,8 @@
  * instruction prefix, stored documents do not. Using the model's official
  * recommended instruction for retrieval tasks.
  */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 const MODEL_ID = 'Xenova/bge-small-zh-v1.5';
 const BGE_QUERY_INSTRUCTION = '为这个句子生成表示以用于检索相关文章：';
 let pipelinePromise = null;
@@ -35,9 +37,16 @@ let pipelinePromise = null;
 function getPipeline() {
     if (!pipelinePromise) {
         pipelinePromise = import('@huggingface/transformers')
-            .then(({ pipeline }) => pipeline('feature-extraction', MODEL_ID, {
-            device: 'cpu',
-        }))
+            .then(({ pipeline, env }) => {
+            env.cacheDir =
+                process.env.YOMI_MODEL_CACHE_DIR ||
+                    (process.platform === 'darwin'
+                        ? join(homedir(), 'Library', 'Caches', 'Yomi', 'models')
+                        : join(process.env.LOCALAPPDATA || homedir(), 'Yomi', 'models'));
+            return pipeline('feature-extraction', MODEL_ID, {
+                device: 'cpu',
+            });
+        })
             .catch((error) => {
             // Reset the memo on failure so a later call can retry (e.g. the
             // first attempt failed offline, network comes back later) instead

package/dist/version.js

@@ -4,4 +4,4 @@
  * virtual filesystem). MUST stay equal to the "version" field in
  * package.json — the test in version.test.ts enforces that.
  */
-export const YOMI_VERSION = '0.5.0';
+export const YOMI_VERSION = '0.6.0';

package/dist/work-item/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/work-item/destination-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/work-item/event-context.js

@@ -0,0 +1,73 @@
+/**
+ * Expand anchors over the event graph rather than taking a fixed number of
+ * neighbouring messages. Edges are traversed in both directions because a
+ * later delivery can revise the meaning of an earlier request.
+ */
+export function assembleEventContext(allMessages, graph, anchorMessageIds, options = {}) {
+    const minimumWeight = options.minimumEdgeWeight ?? 0.3;
+    const maximumMessages = Math.max(1, options.maximumMessages ?? 64);
+    const byId = new Map(allMessages.map((message) => [message.messageId, message]));
+    const validAnchors = [...new Set(anchorMessageIds)].filter((id) => byId.has(id));
+    const chatId = validAnchors.map((id) => byId.get(id).chatId)[0] ?? '';
+    if (validAnchors.length === 0) {
+        return {
+            schemaVersion: 1,
+            chatId,
+            anchorMessageIds: [],
+            messages: [],
+            edges: [],
+            complete: false,
+            boundary: 'missing_anchor',
+        };
+    }
+    const adjacency = new Map();
+    for (const edge of graph.edges.filter((item) => item.weight >= minimumWeight)) {
+        const parent = byId.get(edge.parentId);
+        const child = byId.get(edge.childId);
+        if (!parent ||
+            !child ||
+            parent.chatId !== chatId ||
+            child.chatId !== chatId)
+            continue;
+        adjacency.set(edge.parentId, [
+            ...(adjacency.get(edge.parentId) ?? []),
+            { id: edge.childId, edge },
+        ]);
+        adjacency.set(edge.childId, [
+            ...(adjacency.get(edge.childId) ?? []),
+            { id: edge.parentId, edge },
+        ]);
+    }
+    const distance = new Map(validAnchors.map((id) => [id, 0]));
+    const queue = [...validAnchors];
+    const includedEdges = new Map();
+    let truncated = false;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const next of adjacency.get(current) ?? []) {
+            includedEdges.set(`${next.edge.parentId}:${next.edge.childId}`, next.edge);
+            if (distance.has(next.id))
+                continue;
+            if (distance.size >= maximumMessages) {
+                truncated = true;
+                continue;
+            }
+            distance.set(next.id, (distance.get(current) ?? 0) + 1);
+            queue.push(next.id);
+        }
+    }
+    const messages = [...distance.keys()]
+        .map((id) => byId.get(id))
+        .sort((left, right) => left.sentAt - right.sentAt);
+    const selected = new Set(messages.map((message) => message.messageId));
+    const edges = [...includedEdges.values()].filter((edge) => selected.has(edge.parentId) && selected.has(edge.childId));
+    return {
+        schemaVersion: 1,
+        chatId,
+        anchorMessageIds: validAnchors,
+        messages,
+        edges,
+        complete: !truncated,
+        boundary: truncated ? 'message_limit' : 'graph_boundary',
+    };
+}

package/dist/work-item/gold-contract.js

@@ -0,0 +1,101 @@
+const ACTS = new Set([
+    'inform',
+    'ask',
+    'answer',
+    'directive',
+    'commit',
+    'delegate',
+    'acknowledge',
+    'deliver',
+    'accept',
+    'reject',
+    'cancel',
+]);
+const OWNERSHIP = new Set([
+    'unassigned',
+    'owned',
+    'delegated',
+    'unknown',
+]);
+const OWNER_KINDS = new Set([
+    'self',
+    'conversation_member',
+    'external_party',
+    'unknown',
+]);
+const DEPENDENCIES = new Set([
+    'none',
+    'waiting_person',
+    'waiting_external_system',
+    'waiting_decision',
+    'unknown',
+]);
+const LIFECYCLES = new Set([
+    'proposed',
+    'committed',
+    'in_progress',
+    'blocked',
+    'delivered',
+    'accepted',
+    'cancelled',
+    'resolved',
+    'uncertain',
+]);
+export function validateFactorizedGold(value) {
+    const errors = [];
+    if (!value.id)
+        errors.push('id is required');
+    if (!Array.isArray(value.context) || value.context.length === 0)
+        errors.push('context is required');
+    if (!Number.isInteger(value.targetIndex) ||
+        value.targetIndex < 0 ||
+        value.targetIndex >= value.context.length)
+        errors.push('targetIndex is outside context');
+    if (!value.dialogueActs.length ||
+        value.dialogueActs.some((act) => !ACTS.has(act)))
+        errors.push('dialogueActs are invalid');
+    if (value.createsWork && !value.action)
+        errors.push('work requires an action frame');
+    if (!OWNERSHIP.has(value.ownership.state))
+        errors.push('ownership is invalid');
+    if (!Array.isArray(value.ownership.ownerKinds) ||
+        value.ownership.ownerKinds.length === 0 ||
+        value.ownership.ownerKinds.some((kind) => !OWNER_KINDS.has(kind)))
+        errors.push('ownerKinds are invalid');
+    if (!DEPENDENCIES.has(value.dependency))
+        errors.push('dependency is invalid');
+    if (!LIFECYCLES.has(value.lifecycle))
+        errors.push('lifecycle is invalid');
+    if (value.completion.accepted && !value.completion.delivered)
+        errors.push('acceptance requires delivery');
+    if (value.lifecycle === 'delivered' && !value.completion.delivered)
+        errors.push('delivered lifecycle requires delivery evidence');
+    if (value.lifecycle === 'accepted' && !value.completion.accepted)
+        errors.push('accepted lifecycle requires acceptance evidence');
+    if (value.lifecycle === 'cancelled' && !value.completion.cancelled)
+        errors.push('cancelled lifecycle requires cancellation evidence');
+    if (value.evidenceIndexes) {
+        if (value.evidenceIndexes.length === 0)
+            errors.push('evidenceIndexes cannot be empty');
+        if (new Set(value.evidenceIndexes).size !== value.evidenceIndexes.length)
+            errors.push('evidenceIndexes must be unique');
+        if (value.evidenceIndexes.some((index) => !Number.isInteger(index) ||
+            index < 0 ||
+            index >= value.context.length)) {
+            errors.push('evidenceIndexes are outside context');
+        }
+        if (!value.evidenceIndexes.includes(value.targetIndex))
+            errors.push('evidenceIndexes must include targetIndex');
+    }
+    if (value.evidenceMessageIds) {
+        if (value.evidenceMessageIds.length === 0)
+            errors.push('evidenceMessageIds cannot be empty');
+        if (new Set(value.evidenceMessageIds).size !== value.evidenceMessageIds.length)
+            errors.push('evidenceMessageIds must be unique');
+        if (value.evidenceIndexes &&
+            value.evidenceMessageIds.length !== value.evidenceIndexes.length) {
+            errors.push('evidence index and message id counts differ');
+        }
+    }
+    return errors;
+}

package/dist/work-item/gold-coverage.js

@@ -0,0 +1,96 @@
+export const REQUIRED_GOLD_COVERAGE = {
+    work: ['true', 'false'],
+    dialogue: [
+        'inform',
+        'ask',
+        'answer',
+        'directive',
+        'commit',
+        'delegate',
+        'acknowledge',
+        'deliver',
+        'accept',
+        'reject',
+        'cancel',
+    ],
+    ownership: ['unassigned', 'owned', 'delegated'],
+    dependency: [
+        'none',
+        'waiting_person',
+        'waiting_external_system',
+        'waiting_decision',
+    ],
+    lifecycle: [
+        'proposed',
+        'committed',
+        'in_progress',
+        'blocked',
+        'delivered',
+        'accepted',
+        'cancelled',
+        'resolved',
+    ],
+    completion: ['delivered', 'accepted', 'cancelled'],
+};
+export function factorizedCoverageLabels(record) {
+    return [
+        `work:${record.createsWork}`,
+        ...record.dialogueActs.map((label) => `dialogue:${label}`),
+        `ownership:${record.ownership.state}`,
+        `dependency:${record.dependency}`,
+        `lifecycle:${record.lifecycle}`,
+        ...(record.completion.delivered ? ['completion:delivered'] : []),
+        ...(record.completion.accepted ? ['completion:accepted'] : []),
+        ...(record.completion.cancelled ? ['completion:cancelled'] : []),
+    ];
+}
+function count(records, head, label) {
+    if (head === 'work')
+        return records.filter((record) => String(record.createsWork) === label)
+            .length;
+    if (head === 'dialogue')
+        return records.filter((record) => record.dialogueActs.includes(label)).length;
+    if (head === 'ownership')
+        return records.filter((record) => record.ownership.state === label).length;
+    if (head === 'dependency')
+        return records.filter((record) => record.dependency === label).length;
+    if (head === 'lifecycle')
+        return records.filter((record) => record.lifecycle === label).length;
+    return records.filter((record) => record.completion[label]).length;
+}
+/** Every factorized head must be observable; aggregate sample count is not a gate. */
+export function auditGoldCoverage(split) {
+    const issues = [];
+    for (const partition of ['train', 'validation', 'test']) {
+        const records = split[partition];
+        const required = partition === 'train' ? 2 : 1;
+        for (const [head, labels] of Object.entries(REQUIRED_GOLD_COVERAGE)) {
+            for (const label of labels) {
+                const observed = count(records, head, label);
+                if (observed < required)
+                    issues.push({ partition, head, label, observed, required });
+            }
+        }
+    }
+    return issues;
+}
+export function assertGoldCoverage(split) {
+    const issues = auditGoldCoverage(split);
+    if (issues.length > 0) {
+        const summary = issues
+            .map((issue) => `${issue.partition}.${issue.head}.${issue.label}=${issue.observed}/${issue.required}`)
+            .join(', ');
+        throw new Error(`Factorized gold coverage gate failed: ${summary}`);
+    }
+}
+export function auditAcceptanceCoverage(records) {
+    const observed = new Set(records.flatMap(factorizedCoverageLabels));
+    return Object.entries(REQUIRED_GOLD_COVERAGE)
+        .flatMap(([head, labels]) => labels.map((label) => `${head}:${label}`))
+        .filter((label) => !observed.has(label));
+}
+export function assertAcceptanceCoverage(records) {
+    const missing = auditAcceptanceCoverage(records);
+    if (missing.length > 0)
+        throw new Error(`Independent acceptance coverage gate failed: ${missing.join(', ')}`);
+}

package/dist/work-item/gold-derivation.js

@@ -0,0 +1,67 @@
+export function validateGoldDerivation(value) {
+    const errors = [];
+    if (value.schemaVersion !== 1)
+        errors.push('unsupported schemaVersion');
+    if (!value.derivationId)
+        errors.push('derivationId is required');
+    if (!Number.isInteger(value.revision) || value.revision < 1)
+        errors.push('revision must be positive');
+    if (value.revision === 1 && value.previousRevision !== null)
+        errors.push('first revision cannot have a predecessor');
+    if (value.revision > 1 && value.previousRevision !== value.revision - 1)
+        errors.push('revision chain is invalid');
+    if (!value.conversationId)
+        errors.push('conversationId is required');
+    if (!value.graphEventId)
+        errors.push('graphEventId is required');
+    if (value.reasons.length === 0)
+        errors.push('at least one derivation reason is required');
+    if (new Set(value.evidenceMessageIds).size !== value.evidenceMessageIds.length)
+        errors.push('evidenceMessageIds must be unique');
+    if (new Set(value.derivedGoldIds).size !== value.derivedGoldIds.length)
+        errors.push('derivedGoldIds must be unique');
+    if (value.disposition === 'included' && value.derivedGoldIds.length !== 1)
+        errors.push('included context requires exactly one gold record');
+    if (value.disposition === 'split' && value.derivedGoldIds.length < 2)
+        errors.push('split context requires at least two gold records');
+    if (!['included', 'split'].includes(value.disposition) &&
+        value.derivedGoldIds.length > 0)
+        errors.push('excluded context cannot produce gold records');
+    if (!value.contextComplete &&
+        !value.reasons.includes('context_boundary_truncated') &&
+        !value.reasons.includes('missing_antecedent')) {
+        errors.push('incomplete context requires a boundary reason');
+    }
+    return errors;
+}
+export function createGoldDerivation(input) {
+    const revision = {
+        ...input,
+        schemaVersion: 1,
+        revision: 1,
+        previousRevision: null,
+    };
+    const errors = validateGoldDerivation(revision);
+    if (errors.length > 0)
+        throw new Error(errors.join('; '));
+    return revision;
+}
+/** Revisions make exclusions and earlier interpretations explicitly reversible. */
+export function reviseGoldDerivation(previous, input) {
+    if (previous.derivationId !== input.derivationId)
+        throw new Error('Cannot revise a different derivation');
+    if (previous.conversationId !== input.conversationId ||
+        previous.graphEventId !== input.graphEventId) {
+        throw new Error('Derivation source cannot change across revisions');
+    }
+    const revision = {
+        ...input,
+        schemaVersion: 1,
+        revision: previous.revision + 1,
+        previousRevision: previous.revision,
+    };
+    const errors = validateGoldDerivation(revision);
+    if (errors.length > 0)
+        throw new Error(errors.join('; '));
+    return revision;
+}

package/dist/work-item/gold-split.js

@@ -0,0 +1,143 @@
+function labelsFor(record) {
+    return [
+        `work:${record.createsWork}`,
+        ...record.dialogueActs.map((value) => `dialogue:${value}`),
+        `ownership:${record.ownership.state}`,
+        ...record.ownership.ownerKinds.map((value) => `owner_kind:${value}`),
+        `dependency:${record.dependency}`,
+        `lifecycle:${record.lifecycle}`,
+        `completion:delivered:${record.completion.delivered}`,
+        `completion:accepted:${record.completion.accepted}`,
+        `completion:cancelled:${record.completion.cancelled}`,
+    ];
+}
+function labelCounts(records) {
+    const counts = new Map();
+    for (const record of records) {
+        for (const label of labelsFor(record))
+            counts.set(label, (counts.get(label) ?? 0) + 1);
+    }
+    return counts;
+}
+function stableHash(value) {
+    let hash = 0x811c9dc5;
+    for (const character of value) {
+        hash ^= character.codePointAt(0) ?? 0;
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function conversationId(record) {
+    return record.source?.chatId ?? `synthetic:${record.id}`;
+}
+/**
+ * Assign whole conversations, never windows, to partitions. Public acceptance
+ * fixtures are removed before grouping so they cannot leak into model fitting.
+ */
+export function splitFactorizedGoldByConversation(records, options) {
+    const acceptance = new Set(options.acceptanceIds ?? []);
+    const excludedAcceptanceIds = [];
+    const groups = new Map();
+    for (const record of records) {
+        if (acceptance.has(record.id)) {
+            excludedAcceptanceIds.push(record.id);
+            continue;
+        }
+        const key = conversationId(record);
+        groups.set(key, [...(groups.get(key) ?? []), record]);
+    }
+    const validationFraction = options.validationFraction ?? 0.15;
+    const testFraction = options.testFraction ?? 0.15;
+    if (validationFraction < 0 ||
+        testFraction < 0 ||
+        validationFraction + testFraction >= 1) {
+        throw new Error('Invalid split fractions');
+    }
+    const validationGroups = groups.size >= 3
+        ? Math.max(1, Math.round(groups.size * validationFraction))
+        : 0;
+    const testGroups = groups.size >= 3 ? Math.max(1, Math.round(groups.size * testFraction)) : 0;
+    const trainGroups = Math.max(0, groups.size - validationGroups - testGroups);
+    const allRecords = [...groups.values()].flat();
+    const totals = labelCounts(allRecords);
+    const shares = {
+        train: 1 - validationFraction - testFraction,
+        validation: validationFraction,
+        test: testFraction,
+    };
+    const capacities = {
+        train: trainGroups,
+        validation: validationGroups,
+        test: testGroups,
+    };
+    const assigned = {
+        train: [],
+        validation: [],
+        test: [],
+    };
+    const assignedGroups = { train: 0, validation: 0, test: 0 };
+    const current = {
+        train: new Map(),
+        validation: new Map(),
+        test: new Map(),
+    };
+    const ordered = [...groups.entries()].sort(([leftId, left], [rightId, right]) => {
+        const rarity = (records) => [...new Set(records.flatMap(labelsFor))].reduce((sum, label) => sum + 1 / (totals.get(label) ?? 1), 0);
+        return (rarity(right) - rarity(left) ||
+            stableHash(`${options.seed}:${leftId}`) -
+                stableHash(`${options.seed}:${rightId}`));
+    });
+    for (const [groupId, records] of ordered) {
+        const counts = labelCounts(records);
+        const candidates = ['train', 'validation', 'test'].filter((name) => assignedGroups[name] < capacities[name]);
+        const scored = candidates
+            .map((name) => {
+            let labelNeed = 0;
+            for (const [label, count] of counts) {
+                const target = (totals.get(label) ?? 0) * shares[name];
+                labelNeed +=
+                    (count * Math.max(0, target - (current[name].get(label) ?? 0))) /
+                        Math.max(1, target);
+            }
+            const targetRecords = allRecords.length * shares[name];
+            const sizeNeed = Math.max(0, targetRecords - assigned[name].length) /
+                Math.max(1, targetRecords);
+            return {
+                name,
+                score: labelNeed * 4 + sizeNeed,
+                tie: stableHash(`${options.seed}:${groupId}:${name}`),
+            };
+        })
+            .sort((left, right) => right.score - left.score || left.tie - right.tie);
+        const destination = scored[0]?.name;
+        if (!destination)
+            throw new Error('No partition has remaining conversation capacity');
+        assigned[destination].push(...records);
+        assignedGroups[destination] += 1;
+        for (const [label, count] of counts)
+            current[destination].set(label, (current[destination].get(label) ?? 0) + count);
+    }
+    return {
+        seed: options.seed,
+        train: assigned.train,
+        validation: assigned.validation,
+        test: assigned.test,
+        excludedAcceptanceIds: excludedAcceptanceIds.sort(),
+    };
+}
+export function assertNoConversationLeakage(split) {
+    const seen = new Map();
+    for (const [partition, records] of Object.entries({
+        train: split.train,
+        validation: split.validation,
+        test: split.test,
+    })) {
+        for (const record of records) {
+            const key = conversationId(record);
+            const previous = seen.get(key);
+            if (previous && previous !== partition)
+                throw new Error(`Conversation ${key} leaked from ${previous} into ${partition}`);
+            seen.set(key, partition);
+        }
+    }
+}

package/dist/work-item/index.js

@@ -0,0 +1,23 @@
+export * from './adapter.js';
+export * from './destination-contracts.js';
+export * from './event-context.js';
+export * from './gold-contract.js';
+export * from './gold-coverage.js';
+export * from './gold-derivation.js';
+export * from './gold-split.js';
+export * from './line-adapter.js';
+export * from './llama-cpp-work-event-adapter.js';
+export * from './local-provider.js';
+export * from './local-work-event-provider.js';
+export * from './onnx-work-event-adapter.js';
+export * from './provider.js';
+export * from './registry.js';
+export * from './service.js';
+export * from './store.js';
+export * from './types.js';
+export * from './work-event.js';
+export * from './work-event-graph-engine.js';
+export * from './work-event-inference.js';
+export * from './work-event-matcher.js';
+export * from './work-event-model-manifest.js';
+export * from './work-event-store.js';