@modootoday/pmcp 0.9.2 → 0.10.0

package/dist/config-CJ43_oBS.d.ts

@@ -0,0 +1,49 @@
+import { E as EncoderOptions } from './encoder-DGRy9skC.js';
+
+/**
+ * `pmcp.toml`, the project's one record of where its catalog lives.
+ *
+ * Paths in it are relative to the file, so the same file works from any
+ * directory a host starts pmcp in. Catalog and embedding settings are checked
+ * here; projector sections are kept as given.
+ */
+
+declare const CONFIG_FILE = "pmcp.toml";
+/** What `[catalog]` may say. Each mirrors the repeatable CLI flag of the same meaning. */
+interface CatalogSection {
+    readonly roots?: readonly string[];
+    readonly scopes?: readonly string[];
+    readonly workspaces?: readonly string[];
+    readonly packages?: readonly string[];
+    readonly marketplaces?: readonly string[];
+}
+interface ProjectConfig {
+    /** Absolute path of the file read. */
+    readonly path: string;
+    /** Its directory; every relative path in the file resolves against it. */
+    readonly dir: string;
+    /** `[catalog]` with paths already absolute. */
+    readonly catalog: CatalogSection;
+    readonly embedding?: EmbeddingSection;
+    /** The whole document, for sections this module does not interpret. */
+    readonly raw: Readonly<Record<string, unknown>>;
+}
+interface EmbeddingSection extends EncoderOptions {
+    readonly enabled?: boolean;
+    readonly modelId?: string;
+    readonly modelPath?: string;
+    readonly cacheDir?: string;
+}
+declare class ConfigError extends Error {
+    constructor(path: string, message: string);
+}
+/** The nearest pmcp.toml at or above start, or null when there is none. */
+declare function findConfig(start: string): string | null;
+/**
+ * Reads and checks one file. An unknown key under `[catalog]` is an error
+ * rather than ignored, for the same reason an unknown flag is: a misspelt
+ * `workspace = [...]` must not look like it worked.
+ */
+declare function readConfig(path: string): ProjectConfig;
+
+export { CONFIG_FILE as C, type EmbeddingSection as E, type ProjectConfig as P, type CatalogSection as a, ConfigError as b, findConfig as f, readConfig as r };

package/dist/embed-BBhv3y5x.d.ts

@@ -0,0 +1,53 @@
+import { E as Embedder } from './server-CwWcRjqz.js';
+import { E as EncoderOptions } from './encoder-DGRy9skC.js';
+
+/**
+ * The optional encoder and the store for the vectors it produces.
+ *
+ * Neither the model nor its runtime is a dependency: a caller who wants
+ * semantic ranking installs the peer and runs `pmcp index`, and everything
+ * here degrades to null rather than throwing when that has not happened.
+ */
+
+interface LoadEmbedderOptions extends EncoderOptions {
+    /** Where model files live; a host bakes them into its image here. */
+    readonly cacheDir?: string;
+    readonly modelPath?: string;
+    /** Refuse to download, so a missing model is an error rather than a fetch. */
+    readonly localOnly?: boolean;
+    /** Injected for tests. The optional peer is imported otherwise. */
+    readonly module?: unknown;
+}
+/**
+ * Loads the encoder, or returns null when the peer is not installed.
+ *
+ * Absence is not failure anywhere in this package: the caller reports it and
+ * ranking stays lexical.
+ */
+declare function loadEmbedder(modelId?: string, options?: LoadEmbedderOptions): Promise<Embedder | null>;
+/**
+ * One vector per entry, reusing those whose description has not changed.
+ * Encoded as passages, the side the intent is compared against.
+ */
+declare function encodeEntries(embedder: Embedder, entries: readonly {
+    readonly name: string;
+    readonly description: string;
+}[], previous?: ReadonlyMap<string, {
+    hash: string;
+    vector: Float32Array;
+}>): Promise<Map<string, {
+    hash: string;
+    vector: Float32Array;
+}>>;
+interface EntryVectorStore {
+    read(modelId: string): Map<string, Float32Array>;
+    /** Names whose stored hash disagrees with the description they now have. */
+    stale(modelId: string, entries: ReadonlyMap<string, string>): string[];
+    write(modelId: string, name: string, description: string, vector: Float32Array): void;
+    close(): void;
+}
+declare function openEntryVectors(path: string, options?: {
+    readOnly?: boolean;
+}): Promise<EntryVectorStore | null>;
+
+export { type EntryVectorStore as E, type LoadEmbedderOptions as L, encodeEntries as e, loadEmbedder as l, openEntryVectors as o };

package/dist/encoder-DGRy9skC.d.ts

@@ -0,0 +1,36 @@
+declare const DEFAULT_MODEL_ID = "Xenova/multilingual-e5-small";
+type EncoderDtype = "q4" | "q8" | "fp32";
+interface EncoderSpec {
+    readonly queryPrefix: string;
+    readonly passagePrefix: string;
+    readonly pooling: "mean" | "cls";
+    readonly projected?: boolean;
+}
+interface EncoderOptions {
+    readonly dtype?: EncoderDtype;
+    readonly dimensions?: number;
+    readonly revision?: string;
+    readonly encoder?: Partial<EncoderSpec>;
+}
+interface EmbeddingModel {
+    readonly name: string;
+    readonly modelId: string;
+    readonly dtype: EncoderDtype;
+    readonly dtypes: readonly EncoderDtype[];
+    readonly dimensions: readonly number[];
+    readonly revision: string;
+    readonly encoder: EncoderSpec;
+}
+declare function embeddingModels(): readonly EmbeddingModel[];
+declare function encoderSpec(modelId: string): EncoderSpec;
+interface ResolvedEncoder {
+    readonly modelId: string;
+    readonly dtype: EncoderDtype;
+    readonly dimensions?: number;
+    readonly revision: string;
+    readonly encoder: EncoderSpec;
+    readonly indexKey: string;
+}
+declare function resolveEncoder(model?: string, options?: EncoderOptions): ResolvedEncoder;
+
+export { DEFAULT_MODEL_ID as D, type EncoderOptions as E, type ResolvedEncoder as R, type EmbeddingModel as a, type EncoderDtype as b, type EncoderSpec as c, encoderSpec as d, embeddingModels as e, resolveEncoder as r };

package/dist/http.d.ts

@@ -1,42 +1,10 @@
-import { S as SkillEntry } from './catalog-BU5VLLyd.js';
-import { E as Embedder, S as SkillServerOptions } from './server-C9eO6LMI.js';
+import { S as SkillServerOptions, E as Embedder, a as SkillEntry } from './server-CwWcRjqz.js';
+import { L as LoadEmbedderOptions } from './embed-BBhv3y5x.js';
+export { l as loadEmbedder } from './embed-BBhv3y5x.js';
+import { M as MailboxService } from './service-qpCsOXkQ.js';
+export { D as DEFAULT_MODEL_ID } from './encoder-DGRy9skC.js';
 import 'zod';
 
-/**
- * The optional encoder and the store for the vectors it produces.
- *
- * Neither the model nor its runtime is a dependency: a caller who wants
- * semantic ranking installs the peer and runs `pmcp index`, and everything
- * here degrades to null rather than throwing when that has not happened.
- */
-
-/**
- * What `pmcp index` writes and what the server reads back. Multilingual, so a
- * Korean intent finds an English description (measured 20261005: 8/8 Korean
- * and 8/8 English intents in the top three over a 99-skill catalog).
- */
-declare const DEFAULT_MODEL_ID = "Xenova/multilingual-e5-small";
-interface LoadEmbedderOptions {
-    /** Where model files live; a host bakes them into its image here. */
-    readonly cacheDir?: string;
-    /** Refuse to download, so a missing model is an error rather than a fetch. */
-    readonly localOnly?: boolean;
-    /**
-     * Weight precision. q8 is a quarter of fp32's size (118 MB against 470 MB for
-     * the default model) and ranked the same in the 20261005 measurement.
-     */
-    readonly dtype?: "q8" | "fp32";
-    /** Injected for tests. The optional peer is imported otherwise. */
-    readonly module?: unknown;
-}
-/**
- * Loads the encoder, or returns null when the peer is not installed.
- *
- * Absence is not failure anywhere in this package: the caller reports it and
- * ranking stays lexical.
- */
-declare function loadEmbedder(modelId?: string, options?: LoadEmbedderOptions): Promise<Embedder | null>;
-
 /**
  * Checks a hosted skills server makes before a request reaches MCP: which browser origins
  * and Host names may call it, how large a request may be, and how often one caller may call.
@@ -74,6 +42,7 @@ interface SkillCaller {
     readonly claims?: Readonly<Record<string, unknown>>;
 }
 interface SkillHttpOptions extends SkillServerOptions {
+    readonly mailboxFor?: (caller: SkillCaller) => MailboxService | undefined | Promise<MailboxService | undefined>;
     /** Gets the Request the host's fetch received; read headers only, the body is still unread. */
     readonly authorize: (request: Request) => SkillCaller | undefined | Promise<SkillCaller | undefined>;
     /** Tiers a caller may list and load. Package skills without a tier count as open. */
@@ -111,4 +80,4 @@ interface SkillHttpHandler {
 }
 declare function createSkillHttpHandler(options: SkillHttpOptions): SkillHttpHandler;
 
-export { DEFAULT_MAX_REQUEST_BYTES, DEFAULT_MODEL_ID, DEFAULT_TIERS, Embedder, type RateLimitOptions, type SkillCaller, type SkillHttpHandler, type SkillHttpOptions, type SkillHttpSemanticOptions, createSkillHttpHandler, loadEmbedder, visibleTo };
+export { DEFAULT_MAX_REQUEST_BYTES, DEFAULT_TIERS, Embedder, type RateLimitOptions, type SkillCaller, type SkillHttpHandler, type SkillHttpOptions, type SkillHttpSemanticOptions, createSkillHttpHandler, visibleTo };

package/dist/http.js

@@ -1,13 +1,14 @@
 import {
-  DEFAULT_MODEL_ID,
   encodeEntries,
   loadEmbedder
-} from "./chunk-KYW3VP3L.js";
-import "./chunk-CMZ7OTQD.js";
+} from "./chunk-XEH4ZGGJ.js";
 import {
   createSkillServer,
   readCatalog
-} from "./chunk-A5NOHVHN.js";
+} from "./chunk-VRZFM2M5.js";
+import {
+  DEFAULT_MODEL_ID
+} from "./chunk-XOH2CW6P.js";
 
 // src/http.ts
 import {
@@ -149,13 +150,22 @@ function createSkillHttpHandler(options) {
     }
   };
   let ready = encode();
-  const handlerFor = (tiers) => {
-    const key = [...tiers].sort().join(",");
+  const handlerFor = (tiers, mailbox) => {
+    const key = JSON.stringify({
+      tiers: [...tiers].sort(),
+      mailbox: mailbox ? [
+        mailbox.binding.projectId,
+        mailbox.binding.actorId,
+        mailbox.binding.sessionId,
+        mailbox.binding.generation
+      ] : null
+    });
     const cached = handlers.get(key);
     if (cached) return cached;
     const handler = createMcpHandler(
       () => createSkillServer({
         ...options,
+        ...mailbox ? { mailbox } : {},
         ...embedder && vectors ? { embedder, vectors } : {},
         loadCatalog: () => visibleTo(all, tiers),
         skillsExtension: { cacheScope: options.cacheScope ?? "private" }
@@ -183,7 +193,8 @@ function createSkillHttpHandler(options) {
       options.maxRequestBytes ?? DEFAULT_MAX_REQUEST_BYTES
     );
     if (capped instanceof Response) return capped;
-    return handlerFor(tiersFor(caller)).fetch(capped, {
+    const mailbox = await options.mailboxFor?.(caller);
+    return handlerFor(tiersFor(caller), mailbox).fetch(capped, {
       authInfo: {
         token: "",
         clientId: caller.id,

package/dist/index.d.ts

@@ -1,8 +1,12 @@
-import { I as IntentCache, S as SkillServerOptions, a as SkillTools } from './server-C9eO6LMI.js';
-export { B as BundleFile, C as CATALOG_PAGE_MAX, b as CATALOG_PAGE_SIZE, c as CallResponse, d as CatalogItem, e as CatalogResponse, f as Classified, D as DEFAULT_FIND_LIMIT, g as DESCRIBE_FILE_LIMIT, E as Embedder, F as FileKind, h as FindOptions, i as FindResult, j as IntentCacheStats, K as KindFilter, M as Match, R as READ_BUDGET_BYTES, k as RUNTIMES, l as Ranking, m as ReadResult, n as Runtime, o as SkillBundle, p as SkillFile, q as SkillFileContent, r as SkillFileListing, s as SkillFilters, t as bundleResponseSchema, u as bundleSkill, v as catalogResponseSchema, w as classify, x as cosine, y as createSkillTools, z as describeResponseSchema, A as detectRuntime, G as find, H as findResultSchema, J as isUtf8Text, L as lexicalScore, N as listSkillFiles, O as mimeOf, P as normaliseIntent, Q as readSkillFile, T as runtimeOfClient, U as verifiedRuntimesOf } from './server-C9eO6LMI.js';
-import { S as SkillEntry, M as MetadataValue, C as CatalogOptions } from './catalog-BU5VLLyd.js';
-export { a as ASSET_KINDS, A as AssetKind, b as COMPATIBILITY_MAX, D as DESCRIPTION_MAX, c as MAX_SKILL_DEPTH, d as MetadataLeaf, N as NAME_MAX, e as SKIPPED_DIRS, f as displayPath, k as kindOf, g as parseSkillFrontmatter, r as readBody, h as readCatalog, i as readFrontmatter, s as specProblems, w as withoutBody } from './catalog-BU5VLLyd.js';
+import { I as IntentCache, R as Ranking, S as SkillServerOptions, E as Embedder, C as CatalogOptions, a as SkillEntry, M as MetadataValue, b as SkillTools } from './server-CwWcRjqz.js';
+export { A as ASSET_KINDS, c as AssetKind, B as BundleFile, d as CATALOG_PAGE_MAX, e as CATALOG_PAGE_SIZE, f as COMPATIBILITY_MAX, g as CallResponse, h as CatalogItem, i as CatalogResponse, j as Classified, D as DEFAULT_FIND_LIMIT, k as DESCRIBE_FILE_LIMIT, l as DESCRIPTION_MAX, F as FileKind, m as FindOptions, n as FindResult, o as IntentCacheStats, K as KindFilter, p as MAX_SKILL_DEPTH, q as Match, r as MetadataLeaf, N as NAME_MAX, s as READ_BUDGET_BYTES, t as RUNTIMES, u as ReadResult, v as Runtime, w as SKIPPED_DIRS, x as SkillBundle, y as SkillFile, z as SkillFileContent, G as SkillFileListing, H as SkillFilters, J as bundleResponseSchema, L as bundleSkill, O as catalogResponseSchema, P as classify, Q as cosine, T as createSkillTools, U as describeResponseSchema, V as detectRuntime, W as displayPath, X as find, Y as findResultSchema, Z as isUtf8Text, _ as kindOf, $ as lexicalScore, a0 as listSkillFiles, a1 as mimeOf, a2 as normaliseIntent, a3 as parseSkillFrontmatter, a4 as readBody, a5 as readCatalog, a6 as readFrontmatter, a7 as readSkillFile, a8 as runtimeOfClient, a9 as specProblems, aa as verifiedRuntimesOf, ab as withoutBody } from './server-CwWcRjqz.js';
+import { L as LoadEmbedderOptions } from './embed-BBhv3y5x.js';
+export { E as EntryVectorStore, e as encodeEntries, l as loadEmbedder, o as openEntryVectors } from './embed-BBhv3y5x.js';
+export { D as DEFAULT_MODEL_ID, a as EmbeddingModel, b as EncoderDtype, E as EncoderOptions, c as EncoderSpec, R as ResolvedEncoder, e as embeddingModels, d as encoderSpec, r as resolveEncoder } from './encoder-DGRy9skC.js';
+import { P as ProjectConfig } from './config-CJ43_oBS.js';
+export { C as CONFIG_FILE, a as CatalogSection, b as ConfigError, E as EmbeddingSection, f as findConfig, r as readConfig } from './config-CJ43_oBS.js';
 import { McpServer } from '@modelcontextprotocol/server';
+import { M as MailboxService } from './service-qpCsOXkQ.js';
 import 'zod';
 
 /**
@@ -37,6 +41,19 @@ declare const DEFAULT_INTENT_CACHE_LIMIT = 4096;
  */
 declare function openIntentCache(options: IntentCacheOptions): Promise<IntentCache | null>;
 
+interface SearchOptions extends LoadEmbedderOptions {
+    readonly indexPath: string;
+    readonly modelId?: string;
+    readonly embedder?: Embedder;
+    readonly loadCatalog?: (options: CatalogOptions) => SkillEntry[];
+}
+interface PreparedSearch {
+    readonly ranking: Ranking;
+    readonly reason?: "index_missing" | "index_unavailable" | "index_stale" | "encoder_unavailable" | "vector_mismatch";
+    readonly options: Pick<SkillServerOptions, "embedder" | "vectors" | "loadCatalog">;
+}
+declare function prepareSearch(catalog: CatalogOptions, options: SearchOptions): Promise<PreparedSearch>;
+
 /**
  * Assets laid out as an agent plugin marketplace: a directory holding
  * `.claude-plugin/marketplace.json`, whose plugins keep skills, commands,
@@ -58,44 +75,6 @@ declare function readMarketplace(dir: string, onReject?: (rejection: Rejection)
 /** The directory or single file an entry's describe and read may open. */
 declare const assetRoot: (entry: Pick<SkillEntry, "root" | "path">) => string;
 
-/**
- * `pmcp.toml`, the project's one record of where its catalog lives.
- *
- * Paths in it are relative to the file, so the same file works from any
- * directory a host starts pmcp in. Only `[catalog]` is read here; the other
- * sections belong to the projector and are kept as given.
- */
-declare const CONFIG_FILE = "pmcp.toml";
-/** What `[catalog]` may say. Each mirrors the repeatable CLI flag of the same meaning. */
-interface CatalogSection {
-    readonly roots?: readonly string[];
-    readonly scopes?: readonly string[];
-    readonly workspaces?: readonly string[];
-    readonly packages?: readonly string[];
-    readonly marketplaces?: readonly string[];
-}
-interface ProjectConfig {
-    /** Absolute path of the file read. */
-    readonly path: string;
-    /** Its directory; every relative path in the file resolves against it. */
-    readonly dir: string;
-    /** `[catalog]` with paths already absolute. */
-    readonly catalog: CatalogSection;
-    /** The whole document, for sections this module does not interpret. */
-    readonly raw: Readonly<Record<string, unknown>>;
-}
-declare class ConfigError extends Error {
-    constructor(path: string, message: string);
-}
-/** The nearest pmcp.toml at or above start, or null when there is none. */
-declare function findConfig(start: string): string | null;
-/**
- * Reads and checks one file. An unknown key under `[catalog]` is an error
- * rather than ignored, for the same reason an unknown flag is: a misspelt
- * `workspace = [...]` must not look like it worked.
- */
-declare function readConfig(path: string): ProjectConfig;
-
 /** What the projector writes. A path is unique across a plan and is the lock key. */
 type Output = {
     readonly kind: "link";
@@ -139,6 +118,7 @@ interface PackageRulesSpec {
     readonly strip: readonly string[];
 }
 interface McpServerSpec {
+    readonly mailbox?: boolean;
     readonly command: string;
     readonly args: readonly string[];
     readonly env: Readonly<Record<string, string>>;
@@ -285,7 +265,7 @@ declare function resolveSkillFileUri(uri: string, entries: readonly SkillEntry[]
 
 /** Reported to the host on connect. */
 declare const SERVER_NAME = "pmcp";
-declare const SERVER_VERSION = "0.9.2";
+declare const SERVER_VERSION = "0.10.0";
 /**
  * Registers the skill_* tools on a server.
  *
@@ -294,6 +274,7 @@ declare const SERVER_VERSION = "0.9.2";
  */
 declare function registerSkillTools(server: McpServer, tools: SkillTools): McpServer;
 interface SkillMcpOptions extends SkillServerOptions {
+    readonly mailbox?: MailboxService;
     /** One prompt per skill, for hosts that offer prompts as commands. Off by default. */
     readonly prompts?: boolean;
     readonly skillsExtension?: SkillsExtensionOptions;
@@ -337,4 +318,4 @@ declare function registerSkillResources(server: McpServer, skills: () => readonl
 declare const promptName: (entry: Pick<SkillEntry, "name">) => string;
 declare function registerSkillPrompts(server: McpServer, tools: SkillTools): void;
 
-export { CONFIG_FILE, CatalogOptions, type CatalogSection, ConfigError, DEFAULT_INTENT_CACHE_LIMIT, type Finding$1 as Finding, IntentCache, type IntentCacheOptions, LOCK_FILE, type McpServerSpec, MetadataValue, type Output, type PackageRulesSpec, type ProjectConfig, ProjectError, type ProjectResult, type ProjectSpec, type Rejection, type Runner, SERVER_NAME, SERVER_VERSION, SKILLS_EXTENSION, SkillEntry, type SkillExtensionEntry, type SkillMcpOptions, type SkillResource, SkillServerOptions, SkillTools, TOOLS, type Tool, type Finding as ValidationFinding, assetRoot, createSkillServer, deadGlobs, deriveName, doctor, extensionEntry, findConfig, openIntentCache, plan, project, promptName, readConfig, readFrontmatterText, readMarketplace, readMetadata, readSpec, registerSkillPrompts, registerSkillResources, registerSkillTools, registerSkillsExtension, resolveSkillFileUri, skillFileUri, skillFileUri as skillUri, validateCatalog, validateSkillDir };
+export { CatalogOptions, DEFAULT_INTENT_CACHE_LIMIT, Embedder, type Finding$1 as Finding, IntentCache, type IntentCacheOptions, LOCK_FILE, LoadEmbedderOptions, type McpServerSpec, MetadataValue, type Output, type PackageRulesSpec, type PreparedSearch, ProjectConfig, ProjectError, type ProjectResult, type ProjectSpec, Ranking, type Rejection, type Runner, SERVER_NAME, SERVER_VERSION, SKILLS_EXTENSION, type SearchOptions, SkillEntry, type SkillExtensionEntry, type SkillMcpOptions, type SkillResource, SkillServerOptions, SkillTools, TOOLS, type Tool, type Finding as ValidationFinding, assetRoot, createSkillServer, deadGlobs, deriveName, doctor, extensionEntry, openIntentCache, plan, prepareSearch, project, promptName, readFrontmatterText, readMarketplace, readMetadata, readSpec, registerSkillPrompts, registerSkillResources, registerSkillTools, registerSkillsExtension, resolveSkillFileUri, skillFileUri, skillFileUri as skillUri, validateCatalog, validateSkillDir };

package/dist/index.js

@@ -1,24 +1,24 @@
 import {
-  CONFIG_FILE,
-  ConfigError,
   LOCK_FILE,
   ProjectError,
   TOOLS,
   deadGlobs,
   deriveName,
   doctor,
-  findConfig,
   plan,
+  prepareSearch,
   project,
-  readConfig,
   readSpec,
   validateCatalog,
   validateSkillDir
-} from "./chunk-D3OZVMHN.js";
+} from "./chunk-ZUFFVIHQ.js";
 import {
   DEFAULT_INTENT_CACHE_LIMIT,
+  encodeEntries,
+  loadEmbedder,
+  openEntryVectors,
   openIntentCache
-} from "./chunk-CMZ7OTQD.js";
+} from "./chunk-XEH4ZGGJ.js";
 import {
   ASSET_KINDS,
   CATALOG_PAGE_MAX,
@@ -30,7 +30,6 @@ import {
   MAX_SKILL_DEPTH,
   NAME_MAX,
   READ_BUDGET_BYTES,
-  RUNTIMES,
   SERVER_NAME,
   SERVER_VERSION,
   SKILLS_EXTENSION,
@@ -44,7 +43,6 @@ import {
   createSkillServer,
   createSkillTools,
   describeResponseSchema,
-  detectRuntime,
   displayPath,
   extensionEntry,
   find,
@@ -69,12 +67,26 @@ import {
   registerSkillTools,
   registerSkillsExtension,
   resolveSkillFileUri,
-  runtimeOfClient,
   skillFileUri,
   specProblems,
-  verifiedRuntimesOf,
   withoutBody
-} from "./chunk-A5NOHVHN.js";
+} from "./chunk-VRZFM2M5.js";
+import {
+  CONFIG_FILE,
+  ConfigError,
+  findConfig,
+  readConfig
+} from "./chunk-MSTKY33C.js";
+import {
+  DEFAULT_MODEL_ID,
+  RUNTIMES,
+  detectRuntime,
+  embeddingModels,
+  encoderSpec,
+  resolveEncoder,
+  runtimeOfClient,
+  verifiedRuntimesOf
+} from "./chunk-XOH2CW6P.js";
 export {
   ASSET_KINDS,
   CATALOG_PAGE_MAX,
@@ -84,6 +96,7 @@ export {
   ConfigError,
   DEFAULT_FIND_LIMIT,
   DEFAULT_INTENT_CACHE_LIMIT,
+  DEFAULT_MODEL_ID,
   DESCRIBE_FILE_LIMIT,
   DESCRIPTION_MAX,
   LOCK_FILE,
@@ -111,6 +124,9 @@ export {
   detectRuntime,
   displayPath,
   doctor,
+  embeddingModels,
+  encodeEntries,
+  encoderSpec,
   extensionEntry,
   find,
   findConfig,
@@ -119,11 +135,14 @@ export {
   kindOf,
   lexicalScore,
   listSkillFiles,
+  loadEmbedder,
   mimeOf,
   normaliseIntent,
+  openEntryVectors,
   openIntentCache,
   frontmatterObject as parseSkillFrontmatter,
   plan,
+  prepareSearch,
   project,
   promptName,
   readBody,
@@ -139,6 +158,7 @@ export {
   registerSkillResources,
   registerSkillTools,
   registerSkillsExtension,
+  resolveEncoder,
   resolveSkillFileUri,
   runtimeOfClient,
   skillFileUri,

package/dist/mailbox/index.d.ts

@@ -0,0 +1,44 @@
+import { b as MailboxStore, B as Binding, R as Row, A as ActorCredential, a as MailboxConfig, M as MailboxService } from '../service-qpCsOXkQ.js';
+export { H as HEARTBEAT_INTERVAL_MS, c as MailboxError, d as MailboxOperation, P as PRESENCE_TTL_MS, e as Result, f as failure, i as inboxSchema, m as messageSchema, o as operationSchema, r as restoreBackup, s as sendSchema, g as sessionsSchema } from '../service-qpCsOXkQ.js';
+import { McpServer } from '@modelcontextprotocol/server';
+export { M as MailboxAttachmentOptions, a as attachMailbox } from '../attachment-tU5FZrgZ.js';
+import { P as ProjectConfig } from '../config-CJ43_oBS.js';
+import 'zod';
+import '../encoder-DGRy9skC.js';
+
+declare class NotificationOutbox {
+    readonly store: MailboxStore;
+    constructor(store: MailboxStore);
+    discover(binding: Binding, nativeTarget: string): Promise<void>;
+    retryUnsent(binding: Binding, claim: Row): Promise<void>;
+    reconcile(binding: Binding, messageId: string, delivered: boolean): Promise<void>;
+    enqueue(messageId: string, binding: Binding, nativeTarget: string): Promise<void>;
+    claim(binding: Binding): Promise<Row | undefined>;
+    renew(binding: Binding, claim: Row): Promise<void>;
+    private assertLease;
+    complete(binding: Binding, claim: Row, outcome: "accepted" | "uncertain" | "failed"): Promise<void>;
+}
+
+declare function createRecoveryBundle(store: MailboxStore, credentials: readonly ActorCredential[], destination: string, key: Buffer): Promise<void>;
+declare function restoreRecoveryBundle(source: string, config: MailboxConfig, key: Buffer): Promise<ActorCredential[]>;
+
+declare function registerMailboxTools(server: McpServer, service: MailboxService): McpServer;
+
+declare function mailboxConfigFrom(project: ProjectConfig, env?: Readonly<Record<string, string | undefined>>): MailboxConfig | undefined;
+declare function initializeMailboxConfig(file: string, stateDirectory?: string): MailboxConfig;
+declare function readCredential(file: string): {
+    projectId: string;
+    actorId: string;
+    secret: string;
+};
+declare function readBinding(file: string): {
+    projectId: string;
+    actorId: string;
+    sessionId: string;
+    generation: number;
+    secret: string;
+};
+declare function writePrivateJson(file: string, value: object): void;
+declare function writeBindingFile(file: string, binding: Binding): void;
+
+export { ActorCredential, Binding, MailboxConfig, MailboxService, MailboxStore, NotificationOutbox, createRecoveryBundle, initializeMailboxConfig, mailboxConfigFrom, readBinding, readCredential, registerMailboxTools, restoreRecoveryBundle, writeBindingFile, writePrivateJson };