@openspecui/search 1.1.0

package/dist/index.d.mts

@@ -0,0 +1,316 @@
+import { a as SearchIndexDocument, i as SearchIndex, n as SearchDocumentKind, o as SearchProvider, r as SearchHit, s as SearchQuery, t as SearchDocument } from "./types-B4eONYNW.mjs";
+import { z } from "zod";
+
+//#region src/engine.d.ts
+declare function normalizeText(input: string): string;
+declare function splitTerms(query: string): string[];
+declare function buildSearchIndex(docs: SearchDocument[]): SearchIndex;
+declare function createSnippet(content: string, terms: string[]): string;
+declare function searchIndex(index: SearchIndex, query: SearchQuery): SearchHit[];
+//#endregion
+//#region src/protocol.d.ts
+declare const SearchDocumentKindSchema: z.ZodEnum<["spec", "change", "archive"]>;
+declare const SearchDocumentSchema: z.ZodObject<{
+  id: z.ZodString;
+  kind: z.ZodEnum<["spec", "change", "archive"]>;
+  title: z.ZodString;
+  href: z.ZodString;
+  path: z.ZodString;
+  content: z.ZodString;
+  updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  kind: "spec" | "change" | "archive";
+  title: string;
+  href: string;
+  path: string;
+  content: string;
+  updatedAt: number;
+}, {
+  id: string;
+  kind: "spec" | "change" | "archive";
+  title: string;
+  href: string;
+  path: string;
+  content: string;
+  updatedAt: number;
+}>;
+declare const SearchQuerySchema: z.ZodObject<{
+  query: z.ZodString;
+  limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+  query: string;
+  limit?: number | undefined;
+}, {
+  query: string;
+  limit?: number | undefined;
+}>;
+declare const SearchHitSchema: z.ZodObject<{
+  documentId: z.ZodString;
+  kind: z.ZodEnum<["spec", "change", "archive"]>;
+  title: z.ZodString;
+  href: z.ZodString;
+  path: z.ZodString;
+  score: z.ZodNumber;
+  snippet: z.ZodString;
+  updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+  kind: "spec" | "change" | "archive";
+  title: string;
+  href: string;
+  path: string;
+  updatedAt: number;
+  documentId: string;
+  score: number;
+  snippet: string;
+}, {
+  kind: "spec" | "change" | "archive";
+  title: string;
+  href: string;
+  path: string;
+  updatedAt: number;
+  documentId: string;
+  score: number;
+  snippet: string;
+}>;
+declare const SearchWorkerRequestSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"init">;
+  docs: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["spec", "change", "archive"]>;
+    title: z.ZodString;
+    href: z.ZodString;
+    path: z.ZodString;
+    content: z.ZodString;
+    updatedAt: z.ZodNumber;
+  }, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }, {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  type: "init";
+  docs: {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }[];
+}, {
+  id: string;
+  type: "init";
+  docs: {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }[];
+}>, z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"replaceAll">;
+  docs: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["spec", "change", "archive"]>;
+    title: z.ZodString;
+    href: z.ZodString;
+    path: z.ZodString;
+    content: z.ZodString;
+    updatedAt: z.ZodNumber;
+  }, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }, {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  type: "replaceAll";
+  docs: {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }[];
+}, {
+  id: string;
+  type: "replaceAll";
+  docs: {
+    id: string;
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    content: string;
+    updatedAt: number;
+  }[];
+}>, z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"search">;
+  query: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+  }, "strip", z.ZodTypeAny, {
+    query: string;
+    limit?: number | undefined;
+  }, {
+    query: string;
+    limit?: number | undefined;
+  }>;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  type: "search";
+  query: {
+    query: string;
+    limit?: number | undefined;
+  };
+}, {
+  id: string;
+  type: "search";
+  query: {
+    query: string;
+    limit?: number | undefined;
+  };
+}>, z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"dispose">;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  type: "dispose";
+}, {
+  id: string;
+  type: "dispose";
+}>]>;
+declare const SearchWorkerResponseSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"ok">;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  type: "ok";
+}, {
+  id: string;
+  type: "ok";
+}>, z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"results">;
+  hits: z.ZodArray<z.ZodObject<{
+    documentId: z.ZodString;
+    kind: z.ZodEnum<["spec", "change", "archive"]>;
+    title: z.ZodString;
+    href: z.ZodString;
+    path: z.ZodString;
+    score: z.ZodNumber;
+    snippet: z.ZodString;
+    updatedAt: z.ZodNumber;
+  }, "strip", z.ZodTypeAny, {
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    updatedAt: number;
+    documentId: string;
+    score: number;
+    snippet: string;
+  }, {
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    updatedAt: number;
+    documentId: string;
+    score: number;
+    snippet: string;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  type: "results";
+  hits: {
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    updatedAt: number;
+    documentId: string;
+    score: number;
+    snippet: string;
+  }[];
+}, {
+  id: string;
+  type: "results";
+  hits: {
+    kind: "spec" | "change" | "archive";
+    title: string;
+    href: string;
+    path: string;
+    updatedAt: number;
+    documentId: string;
+    score: number;
+    snippet: string;
+  }[];
+}>, z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodLiteral<"error">;
+  message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  message: string;
+  type: "error";
+}, {
+  id: string;
+  message: string;
+  type: "error";
+}>]>;
+type SearchDocumentInput = z.infer<typeof SearchDocumentSchema>;
+type SearchQueryInput = z.infer<typeof SearchQuerySchema>;
+type SearchHitOutput = z.infer<typeof SearchHitSchema>;
+type SearchWorkerRequest = z.infer<typeof SearchWorkerRequestSchema>;
+type SearchWorkerResponse = z.infer<typeof SearchWorkerResponseSchema>;
+//#endregion
+//#region src/webworker-provider.d.ts
+declare class WebWorkerSearchProvider implements SearchProvider {
+  private worker;
+  private workerUrl;
+  private pending;
+  init(docs: SearchDocument[]): Promise<void>;
+  replaceAll(docs: SearchDocument[]): Promise<void>;
+  search(query: SearchQuery): Promise<SearchHit[]>;
+  dispose(): Promise<void>;
+  private ensureWorker;
+  private sendRequest;
+  private failPending;
+}
+//#endregion
+export { type SearchDocument, type SearchDocumentInput, type SearchDocumentKind, SearchDocumentKindSchema, SearchDocumentSchema, type SearchHit, type SearchHitOutput, SearchHitSchema, type SearchIndex, type SearchIndexDocument, type SearchProvider, type SearchQuery, type SearchQueryInput, SearchQuerySchema, type SearchWorkerRequest, SearchWorkerRequestSchema, type SearchWorkerResponse, SearchWorkerResponseSchema, WebWorkerSearchProvider, buildSearchIndex, createSnippet, normalizeText, searchIndex, splitTerms };

package/dist/index.mjs

@@ -0,0 +1,99 @@
+import { a as SearchHitSchema, c as SearchWorkerResponseSchema, d as normalizeText, f as searchIndex, i as SearchDocumentSchema, l as buildSearchIndex, n as buildWebWorkerSource, o as SearchQuerySchema, p as splitTerms, r as SearchDocumentKindSchema, s as SearchWorkerRequestSchema, u as createSnippet } from "./worker-source-BxMlTiAB.mjs";
+
+//#region src/webworker-provider.ts
+function requestId() {
+	return Math.random().toString(36).slice(2);
+}
+var WebWorkerSearchProvider = class {
+	worker = null;
+	workerUrl = null;
+	pending = /* @__PURE__ */ new Map();
+	async init(docs) {
+		await this.ensureWorker();
+		await this.sendRequest({
+			id: requestId(),
+			type: "init",
+			docs
+		});
+	}
+	async replaceAll(docs) {
+		await this.ensureWorker();
+		await this.sendRequest({
+			id: requestId(),
+			type: "replaceAll",
+			docs
+		});
+	}
+	async search(query) {
+		await this.ensureWorker();
+		return await this.sendRequest({
+			id: requestId(),
+			type: "search",
+			query
+		}) ?? [];
+	}
+	async dispose() {
+		if (this.worker) {
+			await this.sendRequest({
+				id: requestId(),
+				type: "dispose"
+			}).catch(() => {});
+			this.worker.terminate();
+			this.worker = null;
+		}
+		if (this.workerUrl) {
+			URL.revokeObjectURL(this.workerUrl);
+			this.workerUrl = null;
+		}
+		this.failPending(/* @__PURE__ */ new Error("Worker disposed"));
+	}
+	async ensureWorker() {
+		if (this.worker) return;
+		const source = buildWebWorkerSource();
+		const blob = new Blob([source], { type: "text/javascript" });
+		this.workerUrl = URL.createObjectURL(blob);
+		this.worker = new Worker(this.workerUrl, { type: "module" });
+		this.worker.onmessage = (event) => {
+			const parsed = SearchWorkerResponseSchema.safeParse(event.data);
+			if (!parsed.success) {
+				this.failPending(/* @__PURE__ */ new Error("Invalid worker response payload"));
+				return;
+			}
+			const response = parsed.data;
+			const pending = this.pending.get(response.id);
+			if (!pending) return;
+			this.pending.delete(response.id);
+			if (response.type === "error") {
+				pending.reject(new Error(response.message));
+				return;
+			}
+			if (response.type === "results") {
+				pending.resolve(response.hits.map((hit) => SearchHitSchema.parse(hit)));
+				return;
+			}
+			pending.resolve(void 0);
+		};
+		this.worker.onerror = (event) => {
+			const message = event.message || "Web worker runtime error";
+			this.failPending(new Error(message));
+		};
+	}
+	sendRequest(payload) {
+		const worker = this.worker;
+		if (!worker) return Promise.reject(/* @__PURE__ */ new Error("Web worker is not initialized"));
+		return new Promise((resolve, reject) => {
+			this.pending.set(payload.id, {
+				resolve,
+				reject
+			});
+			worker.postMessage(payload);
+		});
+	}
+	failPending(error) {
+		this.pending.forEach(({ reject }) => reject(error));
+		this.pending.clear();
+	}
+};
+
+//#endregion
+export { SearchDocumentKindSchema, SearchDocumentSchema, SearchHitSchema, SearchQuerySchema, SearchWorkerRequestSchema, SearchWorkerResponseSchema, WebWorkerSearchProvider, buildSearchIndex, createSnippet, normalizeText, searchIndex, splitTerms };

package/dist/node.d.mts

@@ -0,0 +1,16 @@
+import { o as SearchProvider, r as SearchHit, s as SearchQuery, t as SearchDocument } from "./types-B4eONYNW.mjs";
+
+//#region src/node-worker-provider.d.ts
+declare class NodeWorkerSearchProvider implements SearchProvider {
+  private worker;
+  private pending;
+  init(docs: SearchDocument[]): Promise<void>;
+  replaceAll(docs: SearchDocument[]): Promise<void>;
+  search(query: SearchQuery): Promise<SearchHit[]>;
+  dispose(): Promise<void>;
+  private ensureWorker;
+  private sendRequest;
+  private failPending;
+}
+//#endregion
+export { NodeWorkerSearchProvider };

package/dist/node.mjs

@@ -0,0 +1,91 @@
+import { a as SearchHitSchema, c as SearchWorkerResponseSchema, t as buildNodeWorkerSource } from "./worker-source-BxMlTiAB.mjs";
+import { Worker } from "node:worker_threads";
+
+//#region src/node-worker-provider.ts
+function requestId() {
+	return Math.random().toString(36).slice(2);
+}
+var NodeWorkerSearchProvider = class {
+	worker = null;
+	pending = /* @__PURE__ */ new Map();
+	async init(docs) {
+		await this.ensureWorker();
+		await this.sendRequest({
+			id: requestId(),
+			type: "init",
+			docs
+		});
+	}
+	async replaceAll(docs) {
+		await this.ensureWorker();
+		await this.sendRequest({
+			id: requestId(),
+			type: "replaceAll",
+			docs
+		});
+	}
+	async search(query) {
+		await this.ensureWorker();
+		return await this.sendRequest({
+			id: requestId(),
+			type: "search",
+			query
+		}) ?? [];
+	}
+	async dispose() {
+		if (this.worker) {
+			await this.sendRequest({
+				id: requestId(),
+				type: "dispose"
+			}).catch(() => {});
+			await this.worker.terminate();
+			this.worker = null;
+		}
+		this.failPending(/* @__PURE__ */ new Error("Worker disposed"));
+	}
+	async ensureWorker() {
+		if (this.worker) return;
+		this.worker = new Worker(buildNodeWorkerSource(), { eval: true });
+		this.worker.on("message", (payload) => {
+			const parsed = SearchWorkerResponseSchema.safeParse(payload);
+			if (!parsed.success) {
+				this.failPending(/* @__PURE__ */ new Error("Invalid worker response payload"));
+				return;
+			}
+			const response = parsed.data;
+			const pending = this.pending.get(response.id);
+			if (!pending) return;
+			this.pending.delete(response.id);
+			if (response.type === "error") {
+				pending.reject(new Error(response.message));
+				return;
+			}
+			if (response.type === "results") {
+				pending.resolve(response.hits.map((hit) => SearchHitSchema.parse(hit)));
+				return;
+			}
+			pending.resolve(void 0);
+		});
+		this.worker.on("error", (error) => {
+			this.failPending(error);
+		});
+	}
+	sendRequest(payload) {
+		const worker = this.worker;
+		if (!worker) return Promise.reject(/* @__PURE__ */ new Error("Node worker is not initialized"));
+		return new Promise((resolve, reject) => {
+			this.pending.set(payload.id, {
+				resolve,
+				reject
+			});
+			worker.postMessage(payload);
+		});
+	}
+	failPending(error) {
+		this.pending.forEach(({ reject }) => reject(error));
+		this.pending.clear();
+	}
+};
+
+//#endregion
+export { NodeWorkerSearchProvider };

package/dist/types-B4eONYNW.d.mts

@@ -0,0 +1,41 @@
+//#region src/types.d.ts
+type SearchDocumentKind = 'spec' | 'change' | 'archive';
+interface SearchDocument {
+  id: string;
+  kind: SearchDocumentKind;
+  title: string;
+  href: string;
+  path: string;
+  content: string;
+  updatedAt: number;
+}
+interface SearchQuery {
+  query: string;
+  limit?: number;
+}
+interface SearchHit {
+  documentId: string;
+  kind: SearchDocumentKind;
+  title: string;
+  href: string;
+  path: string;
+  score: number;
+  snippet: string;
+  updatedAt: number;
+}
+interface SearchProvider {
+  init(docs: SearchDocument[]): Promise<void>;
+  replaceAll(docs: SearchDocument[]): Promise<void>;
+  search(query: SearchQuery): Promise<SearchHit[]>;
+  dispose(): Promise<void>;
+}
+interface SearchIndexDocument extends SearchDocument {
+  normalizedTitle: string;
+  normalizedPath: string;
+  normalizedContent: string;
+}
+interface SearchIndex {
+  documents: SearchIndexDocument[];
+}
+//#endregion
+export { SearchIndexDocument as a, SearchIndex as i, SearchDocumentKind as n, SearchProvider as o, SearchHit as r, SearchQuery as s, SearchDocument as t };

package/dist/worker-source-BxMlTiAB.mjs

@@ -0,0 +1,205 @@
+import { z } from "zod";
+
+//#region src/engine.ts
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+const SNIPPET_SIZE = 180;
+function normalizeText(input) {
+	return input.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function splitTerms(query) {
+	return normalizeText(query).split(" ").map((term) => term.trim()).filter((term) => term.length > 0);
+}
+function toSearchIndexDocument(doc) {
+	return {
+		...doc,
+		normalizedTitle: normalizeText(doc.title),
+		normalizedPath: normalizeText(doc.path),
+		normalizedContent: normalizeText(doc.content)
+	};
+}
+function buildSearchIndex(docs) {
+	return { documents: docs.map(toSearchIndexDocument) };
+}
+function resolveLimit(limit) {
+	if (typeof limit !== "number" || Number.isNaN(limit)) return DEFAULT_LIMIT;
+	return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
+}
+function isDocumentMatch(doc, terms) {
+	return terms.every((term) => doc.normalizedTitle.includes(term) || doc.normalizedPath.includes(term) || doc.normalizedContent.includes(term));
+}
+function scoreDocument(doc, terms) {
+	let score = 0;
+	for (const term of terms) {
+		if (doc.normalizedTitle.includes(term)) score += 30;
+		if (doc.normalizedPath.includes(term)) score += 20;
+		const contentIdx = doc.normalizedContent.indexOf(term);
+		if (contentIdx >= 0) {
+			score += 8;
+			if (contentIdx < 160) score += 4;
+		}
+	}
+	return score;
+}
+function createSnippet(content, terms) {
+	const source = content.trim();
+	if (!source) return "";
+	const normalizedSource = normalizeText(source);
+	let matchIndex = -1;
+	for (const term of terms) {
+		const idx = normalizedSource.indexOf(term);
+		if (idx >= 0 && (matchIndex < 0 || idx < matchIndex)) matchIndex = idx;
+	}
+	if (matchIndex < 0) return source.slice(0, SNIPPET_SIZE);
+	const start = Math.max(0, matchIndex - Math.floor(SNIPPET_SIZE / 3));
+	const end = Math.min(source.length, start + SNIPPET_SIZE);
+	const prefix = start > 0 ? "..." : "";
+	const suffix = end < source.length ? "..." : "";
+	return `${prefix}${source.slice(start, end)}${suffix}`;
+}
+function searchIndex(index, query) {
+	const terms = splitTerms(query.query);
+	if (terms.length === 0) return [];
+	const hits = [];
+	for (const doc of index.documents) {
+		if (!isDocumentMatch(doc, terms)) continue;
+		hits.push({
+			documentId: doc.id,
+			kind: doc.kind,
+			title: doc.title,
+			href: doc.href,
+			path: doc.path,
+			score: scoreDocument(doc, terms),
+			snippet: createSnippet(doc.content, terms),
+			updatedAt: doc.updatedAt
+		});
+	}
+	hits.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		return b.updatedAt - a.updatedAt;
+	});
+	return hits.slice(0, resolveLimit(query.limit));
+}
+
+//#endregion
+//#region src/protocol.ts
+const SearchDocumentKindSchema = z.enum([
+	"spec",
+	"change",
+	"archive"
+]);
+const SearchDocumentSchema = z.object({
+	id: z.string(),
+	kind: SearchDocumentKindSchema,
+	title: z.string(),
+	href: z.string(),
+	path: z.string(),
+	content: z.string(),
+	updatedAt: z.number()
+});
+const SearchQuerySchema = z.object({
+	query: z.string(),
+	limit: z.number().int().positive().optional()
+});
+const SearchHitSchema = z.object({
+	documentId: z.string(),
+	kind: SearchDocumentKindSchema,
+	title: z.string(),
+	href: z.string(),
+	path: z.string(),
+	score: z.number(),
+	snippet: z.string(),
+	updatedAt: z.number()
+});
+const SearchWorkerRequestSchema = z.discriminatedUnion("type", [
+	z.object({
+		id: z.string(),
+		type: z.literal("init"),
+		docs: z.array(SearchDocumentSchema)
+	}),
+	z.object({
+		id: z.string(),
+		type: z.literal("replaceAll"),
+		docs: z.array(SearchDocumentSchema)
+	}),
+	z.object({
+		id: z.string(),
+		type: z.literal("search"),
+		query: SearchQuerySchema
+	}),
+	z.object({
+		id: z.string(),
+		type: z.literal("dispose")
+	})
+]);
+const SearchWorkerResponseSchema = z.discriminatedUnion("type", [
+	z.object({
+		id: z.string(),
+		type: z.literal("ok")
+	}),
+	z.object({
+		id: z.string(),
+		type: z.literal("results"),
+		hits: z.array(SearchHitSchema)
+	}),
+	z.object({
+		id: z.string(),
+		type: z.literal("error"),
+		message: z.string()
+	})
+]);
+
+//#endregion
+//#region src/worker-source.ts
+const sharedRuntimeSource = String.raw`
+const DEFAULT_LIMIT = 50;
+const MAX_LIMIT = 200;
+const SNIPPET_SIZE = 180;
+const normalizeText = ${normalizeText.toString()};
+const splitTerms = ${splitTerms.toString()};
+const toSearchIndexDocument = ${toSearchIndexDocument.toString()};
+const buildSearchIndex = ${buildSearchIndex.toString()};
+const resolveLimit = ${resolveLimit.toString()};
+const isDocumentMatch = ${isDocumentMatch.toString()};
+const scoreDocument = ${scoreDocument.toString()};
+const createSnippet = ${createSnippet.toString()};
+const searchIndex = ${searchIndex.toString()};
+let index = buildSearchIndex([]);
+
+function handleMessage(payload) {
+  try {
+    if (!payload || typeof payload !== 'object') {
+      throw new Error('Invalid worker request payload');
+    }
+
+    if (payload.type === 'init' || payload.type === 'replaceAll') {
+      index = buildSearchIndex(Array.isArray(payload.docs) ? payload.docs : []);
+      return { id: payload.id, type: 'ok' };
+    }
+
+    if (payload.type === 'search') {
+      const hits = searchIndex(index, payload.query || { query: '' });
+      return { id: payload.id, type: 'results', hits };
+    }
+
+    if (payload.type === 'dispose') {
+      index = buildSearchIndex([]);
+      return { id: payload.id, type: 'ok' };
+    }
+
+    throw new Error('Unsupported worker request type');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { id: payload?.id ?? 'unknown', type: 'error', message };
+  }
+}
+`;
+function buildWebWorkerSource() {
+	return `${sharedRuntimeSource}\nself.onmessage = (event) => { self.postMessage(handleMessage(event.data)); };`;
+}
+function buildNodeWorkerSource() {
+	return `${sharedRuntimeSource}\nconst { parentPort } = require('node:worker_threads');\nif (!parentPort) { throw new Error('Missing parentPort'); }\nparentPort.on('message', (payload) => { parentPort.postMessage(handleMessage(payload)); });`;
+}
+
+//#endregion
+export { SearchHitSchema as a, SearchWorkerResponseSchema as c, normalizeText as d, searchIndex as f, SearchDocumentSchema as i, buildSearchIndex as l, buildWebWorkerSource as n, SearchQuerySchema as o, splitTerms as p, SearchDocumentKindSchema as r, SearchWorkerRequestSchema as s, buildNodeWorkerSource as t, createSnippet as u };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@openspecui/search",
+  "version": "1.1.0",
+  "description": "Shared search engine and worker providers for OpenSpecUI",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./node": {
+      "import": "./dist/node.mjs",
+      "types": "./dist/node.d.mts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "tsdown": "^0.16.6",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/node.ts --format esm --dts",
+    "dev": "tsdown src/index.ts src/node.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}