wiki-graph-core 0.3.1

package/dist/wikimatch/surface-screening.js

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import {
+  ParsedJsonError,
+  RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,
+  requestGuaranteedJson
+} from "../guaranteed/index.js";
+const protectedSurfaceSchema = z.object({
+  note: z.string().max(24).optional(),
+  surfaceId: z.string().min(1)
+}).strict();
+const protectionResponseSchema = z.object({
+  protectedSurfaces: z.array(protectedSurfaceSchema)
+}).strict();
+async function judgeWikimatchSurfaceProtection(options) {
+  if (options.suspiciousSurfaces.length === 0) {
+    return { protectedSurfaces: [] };
+  }
+  try {
+    return await requestGuaranteedJson({
+      messages: buildProtectionMessages(options),
+      parse: (response) => parseSurfaceProtectionResponse(
+        options.suspiciousSurfaces,
+        normalizeProtectionResponse(response)
+      ),
+      request: options.request,
+      responseIntentClassifierPrompt: RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,
+      schema: protectionResponseSchema,
+      ...options.maxRetries === void 0 ? {} : { maxRetries: options.maxRetries }
+    });
+  } catch (error) {
+    return {
+      fallback: {
+        issues: [formatFallbackIssue(error)],
+        reason: "guaranteed_json_failed"
+      },
+      protectedSurfaces: []
+    };
+  }
+}
+function normalizeProtectionResponse(response) {
+  return {
+    protectedSurfaces: response.protectedSurfaces.map((surface) => ({
+      ...surface.note === void 0 ? {} : { note: surface.note },
+      surfaceId: surface.surfaceId
+    }))
+  };
+}
+function parseSurfaceProtectionResponse(surfaces, response) {
+  const issues = validateSurfaceProtectionResponse(surfaces, response);
+  if (issues.length > 0) {
+    throw new ParsedJsonError(issues);
+  }
+  const surfacesById = createSurfaceMap(surfaces);
+  const protectedSurfaces = [];
+  for (const surface of response.protectedSurfaces) {
+    const source = surfacesById.get(surface.surfaceId);
+    protectedSurfaces.push({
+      ...surface.note === void 0 ? {} : { note: surface.note },
+      surfaceId: surface.surfaceId,
+      text: source.text
+    });
+  }
+  return { protectedSurfaces };
+}
+function validateSurfaceProtectionResponse(surfaces, response) {
+  const issues = [];
+  const surfacesById = createSurfaceMap(surfaces);
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const surface of response.protectedSurfaces) {
+    if (!surfacesById.has(surface.surfaceId)) {
+      issues.push(
+        `Unknown surfaceId "${surface.surfaceId}". Use only these surface IDs: ${[
+          ...surfacesById.keys()
+        ].join(", ")}.`
+      );
+      continue;
+    }
+    if (seenIds.has(surface.surfaceId)) {
+      issues.push(`Duplicate protected surface ${surface.surfaceId}.`);
+      continue;
+    }
+    seenIds.add(surface.surfaceId);
+  }
+  return issues;
+}
+function buildProtectionMessages(input) {
+  return [
+    {
+      role: "system",
+      content: formatProtectionSystemPrompt(input)
+    },
+    {
+      role: "user",
+      content: formatProtectionPrompt(input)
+    }
+  ];
+}
+function formatProtectionSystemPrompt(input) {
+  return [
+    "You protect useful high-frequency surface strings before Wikidata grounding.",
+    "",
+    "The input surfaces are suspicious only because they are frequent after range suppression.",
+    "Most high-frequency function words, fragments, punctuation, generic words, and discourse words should NOT be protected.",
+    "A surface that is not protected will be removed before grounding.",
+    "",
+    "User recall policy:",
+    input.policyPrompt,
+    "",
+    "Protect a surface only when it is likely to be a meaningful entity, named concept, named event, place, person, organization, work, or domain term under the policy.",
+    "",
+    "Rules:",
+    "- Return JSON only.",
+    "- Return only protected surface IDs.",
+    "- Do not return a result for every input surface.",
+    "- Do not protect generic grammar words merely because they appear often.",
+    "- Do not infer or choose Wikidata QIDs in this stage."
+  ].join("\n");
+}
+function formatProtectionPrompt(input) {
+  return [
+    "Suspicious high-frequency surfaces:",
+    JSON.stringify(
+      input.suspiciousSurfaces.map((surface) => ({
+        count: surface.count,
+        surfaceId: surface.id,
+        text: surface.text
+      })),
+      null,
+      2
+    ),
+    "",
+    "Return this JSON shape:",
+    JSON.stringify(
+      {
+        protectedSurfaces: [
+          {
+            note: "optional, <= 12 Chinese chars or 6 English words",
+            surfaceId: "surface id from the input"
+          }
+        ]
+      },
+      null,
+      2
+    )
+  ].join("\n");
+}
+function createSurfaceMap(surfaces) {
+  return new Map(surfaces.map((surface) => [surface.id, surface]));
+}
+function formatFallbackIssue(error) {
+  if (error instanceof ParsedJsonError) {
+    return error.issues.join("\n");
+  }
+  if (error instanceof Error) {
+    const issues = error.issues;
+    if (Array.isArray(issues) && issues.every((issue) => typeof issue === "string")) {
+      return issues.join("\n");
+    }
+    return error.message;
+  }
+  return String(error);
+}
+export {
+  judgeWikimatchSurfaceProtection,
+  parseSurfaceProtectionResponse,
+  validateSurfaceProtectionResponse
+};
+//# sourceMappingURL=surface-screening.js.map

package/dist/wikimatch/surface-screening.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wikimatch/surface-screening.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport {\n  ParsedJsonError,\n  RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,\n  requestGuaranteedJson,\n  type GuaranteedRequest,\n} from \"../guaranteed/index.js\";\nimport type { LLMessage } from \"../llm/index.js\";\n\nimport type {\n  WikimatchProtectedSurface,\n  WikimatchSurface,\n  WikimatchSurfaceProtectionInput,\n  WikimatchSurfaceProtectionResponse,\n  WikimatchSurfaceProtectionResult,\n} from \"./types.js\";\n\nconst protectedSurfaceSchema = z\n  .object({\n    note: z.string().max(24).optional(),\n    surfaceId: z.string().min(1),\n  })\n  .strict();\n\nconst protectionResponseSchema = z\n  .object({\n    protectedSurfaces: z.array(protectedSurfaceSchema),\n  })\n  .strict();\n\nexport interface JudgeWikimatchSurfaceProtectionOptions extends WikimatchSurfaceProtectionInput {\n  readonly maxRetries?: number;\n  readonly request: GuaranteedRequest;\n}\n\nexport async function judgeWikimatchSurfaceProtection(\n  options: JudgeWikimatchSurfaceProtectionOptions,\n): Promise<WikimatchSurfaceProtectionResult> {\n  if (options.suspiciousSurfaces.length === 0) {\n    return { protectedSurfaces: [] };\n  }\n\n  try {\n    return await requestGuaranteedJson({\n      messages: buildProtectionMessages(options),\n      parse: (response) =>\n        parseSurfaceProtectionResponse(\n          options.suspiciousSurfaces,\n          normalizeProtectionResponse(response),\n        ),\n      request: options.request,\n      responseIntentClassifierPrompt:\n        RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,\n      schema: protectionResponseSchema,\n      ...(options.maxRetries === undefined\n        ? {}\n        : { maxRetries: options.maxRetries }),\n    });\n  } catch (error) {\n    return {\n      fallback: {\n        issues: [formatFallbackIssue(error)],\n        reason: \"guaranteed_json_failed\",\n      },\n      protectedSurfaces: [],\n    };\n  }\n}\n\nfunction normalizeProtectionResponse(\n  response: z.infer<typeof protectionResponseSchema>,\n): WikimatchSurfaceProtectionResponse {\n  return {\n    protectedSurfaces: response.protectedSurfaces.map((surface) => ({\n      ...(surface.note === undefined ? {} : { note: surface.note }),\n      surfaceId: surface.surfaceId,\n    })),\n  };\n}\n\nexport function parseSurfaceProtectionResponse(\n  surfaces: readonly WikimatchSurface[],\n  response: WikimatchSurfaceProtectionResponse,\n): WikimatchSurfaceProtectionResult {\n  const issues = validateSurfaceProtectionResponse(surfaces, response);\n\n  if (issues.length > 0) {\n    throw new ParsedJsonError(issues);\n  }\n\n  const surfacesById = createSurfaceMap(surfaces);\n  const protectedSurfaces: WikimatchProtectedSurface[] = [];\n\n  for (const surface of response.protectedSurfaces) {\n    const source = surfacesById.get(surface.surfaceId)!;\n\n    protectedSurfaces.push({\n      ...(surface.note === undefined ? {} : { note: surface.note }),\n      surfaceId: surface.surfaceId,\n      text: source.text,\n    });\n  }\n\n  return { protectedSurfaces };\n}\n\nexport function validateSurfaceProtectionResponse(\n  surfaces: readonly WikimatchSurface[],\n  response: WikimatchSurfaceProtectionResponse,\n): readonly string[] {\n  const issues: string[] = [];\n  const surfacesById = createSurfaceMap(surfaces);\n  const seenIds = new Set<string>();\n\n  for (const surface of response.protectedSurfaces) {\n    if (!surfacesById.has(surface.surfaceId)) {\n      issues.push(\n        `Unknown surfaceId \"${surface.surfaceId}\". Use only these surface IDs: ${[\n          ...surfacesById.keys(),\n        ].join(\", \")}.`,\n      );\n      continue;\n    }\n    if (seenIds.has(surface.surfaceId)) {\n      issues.push(`Duplicate protected surface ${surface.surfaceId}.`);\n      continue;\n    }\n\n    seenIds.add(surface.surfaceId);\n  }\n\n  return issues;\n}\n\nfunction buildProtectionMessages(\n  input: WikimatchSurfaceProtectionInput,\n): LLMessage[] {\n  return [\n    {\n      role: \"system\",\n      content: formatProtectionSystemPrompt(input),\n    },\n    {\n      role: \"user\",\n      content: formatProtectionPrompt(input),\n    },\n  ];\n}\n\nfunction formatProtectionSystemPrompt(\n  input: WikimatchSurfaceProtectionInput,\n): string {\n  return [\n    \"You protect useful high-frequency surface strings before Wikidata grounding.\",\n    \"\",\n    \"The input surfaces are suspicious only because they are frequent after range suppression.\",\n    \"Most high-frequency function words, fragments, punctuation, generic words, and discourse words should NOT be protected.\",\n    \"A surface that is not protected will be removed before grounding.\",\n    \"\",\n    \"User recall policy:\",\n    input.policyPrompt,\n    \"\",\n    \"Protect a surface only when it is likely to be a meaningful entity, named concept, named event, place, person, organization, work, or domain term under the policy.\",\n    \"\",\n    \"Rules:\",\n    \"- Return JSON only.\",\n    \"- Return only protected surface IDs.\",\n    \"- Do not return a result for every input surface.\",\n    \"- Do not protect generic grammar words merely because they appear often.\",\n    \"- Do not infer or choose Wikidata QIDs in this stage.\",\n  ].join(\"\\n\");\n}\n\nfunction formatProtectionPrompt(\n  input: WikimatchSurfaceProtectionInput,\n): string {\n  return [\n    \"Suspicious high-frequency surfaces:\",\n    JSON.stringify(\n      input.suspiciousSurfaces.map((surface) => ({\n        count: surface.count,\n        surfaceId: surface.id,\n        text: surface.text,\n      })),\n      null,\n      2,\n    ),\n    \"\",\n    \"Return this JSON shape:\",\n    JSON.stringify(\n      {\n        protectedSurfaces: [\n          {\n            note: \"optional, <= 12 Chinese chars or 6 English words\",\n            surfaceId: \"surface id from the input\",\n          },\n        ],\n      },\n      null,\n      2,\n    ),\n  ].join(\"\\n\");\n}\n\nfunction createSurfaceMap(\n  surfaces: readonly WikimatchSurface[],\n): ReadonlyMap<string, WikimatchSurface> {\n  return new Map(surfaces.map((surface) => [surface.id, surface]));\n}\n\nfunction formatFallbackIssue(error: unknown): string {\n  if (error instanceof ParsedJsonError) {\n    return error.issues.join(\"\\n\");\n  }\n  if (error instanceof Error) {\n    const issues = (error as { readonly issues?: unknown }).issues;\n\n    if (\n      Array.isArray(issues) &&\n      issues.every((issue) => typeof issue === \"string\")\n    ) {\n      return issues.join(\"\\n\");\n    }\n\n    return error.message;\n  }\n\n  return String(error);\n}\n"],"mappings":"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","names":[]}

package/dist/wikimatch/surface-window.d.ts

@@ -0,0 +1,6 @@
+import { BuildWikimatchSurfaceProtectionInputOptions, WikimatchSurfaceProtectionBuildResult } from './types.js';
+import '../wikipage/types.js';
+
+declare function buildWikimatchSurfaceProtectionInput(options: BuildWikimatchSurfaceProtectionInputOptions): WikimatchSurfaceProtectionBuildResult;
+
+export { buildWikimatchSurfaceProtectionInput };

package/dist/wikimatch/surface-window.js

@@ -0,0 +1,44 @@
+import { suppressContainedRanges } from "./range-suppression.js";
+function buildWikimatchSurfaceProtectionInput(options) {
+  const suppressedCandidates = suppressContainedRanges(options.candidates);
+  const surfaces = listSurfaces(suppressedCandidates, options.text);
+  const suspiciousSurfaces = selectTopSurfaces(surfaces, options.percentile);
+  const suspiciousTexts = new Set(
+    suspiciousSurfaces.map((surface) => surface.text)
+  );
+  return {
+    candidates: suppressedCandidates.filter(
+      (candidate) => !suspiciousTexts.has(
+        options.text.slice(candidate.range.start, candidate.range.end)
+      )
+    ),
+    suppressedCandidates,
+    suspiciousSurfaces
+  };
+}
+function listSurfaces(candidates, text) {
+  const surfaces = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const surface = text.slice(candidate.range.start, candidate.range.end);
+    surfaces.set(surface, (surfaces.get(surface) ?? 0) + 1);
+  }
+  return [...surfaces.entries()].map(([surface, count], index) => ({
+    count,
+    id: `s${index + 1}`,
+    text: surface
+  })).sort(compareSurface);
+}
+function selectTopSurfaces(surfaces, percentile) {
+  if (surfaces.length === 0 || percentile <= 0) {
+    return [];
+  }
+  const count = Math.ceil(surfaces.length * Math.min(1, percentile));
+  return surfaces.slice(0, count);
+}
+function compareSurface(left, right) {
+  return right.count - left.count || left.text.localeCompare(right.text) || left.id.localeCompare(right.id);
+}
+export {
+  buildWikimatchSurfaceProtectionInput
+};
+//# sourceMappingURL=surface-window.js.map

package/dist/wikimatch/surface-window.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wikimatch/surface-window.ts"],"sourcesContent":["import type {\n  BuildWikimatchSurfaceProtectionInputOptions,\n  WikimatchCandidate,\n  WikimatchSurface,\n  WikimatchSurfaceProtectionBuildResult,\n} from \"./types.js\";\nimport { suppressContainedRanges } from \"./range-suppression.js\";\n\nexport function buildWikimatchSurfaceProtectionInput(\n  options: BuildWikimatchSurfaceProtectionInputOptions,\n): WikimatchSurfaceProtectionBuildResult {\n  const suppressedCandidates = suppressContainedRanges(options.candidates);\n  const surfaces = listSurfaces(suppressedCandidates, options.text);\n  const suspiciousSurfaces = selectTopSurfaces(surfaces, options.percentile);\n  const suspiciousTexts = new Set(\n    suspiciousSurfaces.map((surface) => surface.text),\n  );\n\n  return {\n    candidates: suppressedCandidates.filter(\n      (candidate) =>\n        !suspiciousTexts.has(\n          options.text.slice(candidate.range.start, candidate.range.end),\n        ),\n    ),\n    suppressedCandidates,\n    suspiciousSurfaces,\n  };\n}\n\nfunction listSurfaces(\n  candidates: readonly WikimatchCandidate[],\n  text: string,\n): readonly WikimatchSurface[] {\n  const surfaces = new Map<string, number>();\n\n  for (const candidate of candidates) {\n    const surface = text.slice(candidate.range.start, candidate.range.end);\n\n    surfaces.set(surface, (surfaces.get(surface) ?? 0) + 1);\n  }\n\n  return [...surfaces.entries()]\n    .map(([surface, count], index) => ({\n      count,\n      id: `s${index + 1}`,\n      text: surface,\n    }))\n    .sort(compareSurface);\n}\n\nfunction selectTopSurfaces(\n  surfaces: readonly WikimatchSurface[],\n  percentile: number,\n): readonly WikimatchSurface[] {\n  if (surfaces.length === 0 || percentile <= 0) {\n    return [];\n  }\n\n  const count = Math.ceil(surfaces.length * Math.min(1, percentile));\n\n  return surfaces.slice(0, count);\n}\n\nfunction compareSurface(\n  left: WikimatchSurface,\n  right: WikimatchSurface,\n): number {\n  return (\n    right.count - left.count ||\n    left.text.localeCompare(right.text) ||\n    left.id.localeCompare(right.id)\n  );\n}\n"],"mappings":"AAMA,SAAS,+BAA+B;AAEjC,SAAS,qCACd,SACuC;AACvC,QAAM,uBAAuB,wBAAwB,QAAQ,UAAU;AACvE,QAAM,WAAW,aAAa,sBAAsB,QAAQ,IAAI;AAChE,QAAM,qBAAqB,kBAAkB,UAAU,QAAQ,UAAU;AACzE,QAAM,kBAAkB,IAAI;AAAA,IAC1B,mBAAmB,IAAI,CAAC,YAAY,QAAQ,IAAI;AAAA,EAClD;AAEA,SAAO;AAAA,IACL,YAAY,qBAAqB;AAAA,MAC/B,CAAC,cACC,CAAC,gBAAgB;AAAA,QACf,QAAQ,KAAK,MAAM,UAAU,MAAM,OAAO,UAAU,MAAM,GAAG;AAAA,MAC/D;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,aACP,YACA,MAC6B;AAC7B,QAAM,WAAW,oBAAI,IAAoB;AAEzC,aAAW,aAAa,YAAY;AAClC,UAAM,UAAU,KAAK,MAAM,UAAU,MAAM,OAAO,UAAU,MAAM,GAAG;AAErE,aAAS,IAAI,UAAU,SAAS,IAAI,OAAO,KAAK,KAAK,CAAC;AAAA,EACxD;AAEA,SAAO,CAAC,GAAG,SAAS,QAAQ,CAAC,EAC1B,IAAI,CAAC,CAAC,SAAS,KAAK,GAAG,WAAW;AAAA,IACjC;AAAA,IACA,IAAI,IAAI,QAAQ,CAAC;AAAA,IACjB,MAAM;AAAA,EACR,EAAE,EACD,KAAK,cAAc;AACxB;AAEA,SAAS,kBACP,UACA,YAC6B;AAC7B,MAAI,SAAS,WAAW,KAAK,cAAc,GAAG;AAC5C,WAAO,CAAC;AAAA,EACV;AAEA,QAAM,QAAQ,KAAK,KAAK,SAAS,SAAS,KAAK,IAAI,GAAG,UAAU,CAAC;AAEjE,SAAO,SAAS,MAAM,GAAG,KAAK;AAChC;AAEA,SAAS,eACP,MACA,OACQ;AACR,SACE,MAAM,QAAQ,KAAK,SACnB,KAAK,KAAK,cAAc,MAAM,IAAI,KAClC,KAAK,GAAG,cAAc,MAAM,EAAE;AAElC;","names":[]}

package/dist/wikimatch/types.d.ts

@@ -0,0 +1,151 @@
+import { DisambiguationExpansion } from '../wikipage/types.js';
+
+interface WikimatchCandidate {
+    readonly hasMoreOptions?: boolean;
+    readonly id: string;
+    readonly qidOptions: readonly WikimatchQidOption[];
+    readonly range: WikimatchTextRange;
+    readonly surface: string;
+}
+interface WikimatchSentence {
+    readonly id?: string;
+    readonly range: WikimatchTextRange;
+    readonly text: string;
+}
+interface WikimatchQidOption {
+    readonly description?: string;
+    readonly disambiguation?: DisambiguationExpansion;
+    readonly isDisambiguation?: boolean;
+    readonly label?: string;
+    readonly qid: string;
+}
+interface WikimatchTextRange {
+    readonly end: number;
+    readonly start: number;
+}
+interface WikimatchWindow {
+    readonly baseOffset: number;
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly groups: readonly WikimatchConflictGroup[];
+    readonly text: string;
+}
+interface WikimatchSurface {
+    readonly id: string;
+    readonly count: number;
+    readonly text: string;
+}
+interface WikimatchConflictGroup {
+    readonly candidateIds: readonly string[];
+    readonly id: string;
+    readonly range: WikimatchTextRange;
+}
+interface BuildWikimatchWindowsOptions {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly contextWords: number;
+    readonly optionBudget: number;
+    readonly text: string;
+}
+interface NarrowWikimatchCandidateOptionsInput {
+    readonly candidate: WikimatchCandidate;
+    readonly policyPrompt: string;
+    readonly text: string;
+}
+interface WikimatchCandidateOptionNarrowingResult {
+    readonly candidate: WikimatchCandidate;
+    readonly fallback?: WikimatchCandidateOptionNarrowingFallback;
+}
+interface WikimatchCandidateOptionNarrowingFallback {
+    readonly issues: readonly string[];
+    readonly reason: "guaranteed_json_failed";
+}
+interface WikimatchCandidateOptionNarrowingResponse {
+    readonly qids: readonly WikimatchCandidateOptionNarrowingItemOutput[];
+}
+interface WikimatchCandidateOptionNarrowingItemOutput {
+    readonly decision: "keep" | "reject";
+    readonly qid: string;
+}
+interface BuildWikimatchSurfaceProtectionInputOptions {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly percentile: number;
+    readonly text: string;
+}
+interface WikimatchSurfaceProtectionInput {
+    readonly policyPrompt: string;
+    readonly suspiciousSurfaces: readonly WikimatchSurface[];
+}
+interface WikimatchSurfaceProtectionBuildResult {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly suppressedCandidates: readonly WikimatchCandidate[];
+    readonly suspiciousSurfaces: readonly WikimatchSurface[];
+}
+interface WikimatchSurfaceProtectionResult {
+    readonly fallback?: WikimatchSurfaceProtectionFallback;
+    readonly protectedSurfaces: readonly WikimatchProtectedSurface[];
+}
+interface WikimatchProtectedSurface {
+    readonly note?: string;
+    readonly surfaceId: string;
+    readonly text: string;
+}
+interface WikimatchSurfaceProtectionFallback {
+    readonly issues: readonly string[];
+    readonly reason: "guaranteed_json_failed";
+}
+interface WikimatchProtectedSurfaceOutput {
+    readonly note?: string;
+    readonly surfaceId: string;
+}
+interface WikimatchSurfaceProtectionResponse {
+    readonly protectedSurfaces: readonly WikimatchProtectedSurfaceOutput[];
+}
+type WikimatchPolicyDecision = "continue" | "never_recall" | "recall" | "skip_this_time";
+interface WikimatchPolicyJudgeInput {
+    readonly candidates: readonly WikimatchCandidate[];
+    readonly policyPrompt: string;
+    readonly window: WikimatchWindow;
+}
+interface WikimatchPolicyJudgeResult {
+    readonly continuations: readonly WikimatchPolicyContinuation[];
+    readonly fallback?: WikimatchPolicyFallback;
+    readonly mentions: readonly WikimatchAcceptedMention[];
+    readonly policyUpdates: readonly WikimatchPolicyUpdate[];
+}
+interface WikimatchAcceptedMention {
+    readonly candidateId: string;
+    readonly confidence?: number;
+    readonly qid: string;
+    readonly range: WikimatchTextRange;
+    readonly note?: string;
+    readonly surface: string;
+}
+interface WikimatchPolicyUpdate {
+    readonly candidateId: string;
+    readonly decision: Exclude<WikimatchPolicyDecision, "recall" | "continue">;
+    readonly note?: string;
+    readonly qid?: string;
+    readonly surface: string;
+}
+interface WikimatchPolicyContinuation {
+    readonly candidateIds: readonly string[];
+    readonly groupId: string;
+}
+interface WikimatchPolicyFallback {
+    readonly issues: readonly string[];
+    readonly reason: "guaranteed_json_failed";
+}
+interface WikimatchPolicyDecisionOutput {
+    readonly candidateId: string;
+    readonly confidence?: number;
+    readonly decision: WikimatchPolicyDecision;
+    readonly qid?: string;
+}
+interface WikimatchPolicyGroupOutput {
+    readonly decisions: readonly WikimatchPolicyDecisionOutput[];
+    readonly groupId: string;
+}
+interface WikimatchPolicyResponse {
+    readonly groups: readonly WikimatchPolicyGroupOutput[];
+}
+
+export type { BuildWikimatchSurfaceProtectionInputOptions, BuildWikimatchWindowsOptions, NarrowWikimatchCandidateOptionsInput, WikimatchAcceptedMention, WikimatchCandidate, WikimatchCandidateOptionNarrowingFallback, WikimatchCandidateOptionNarrowingItemOutput, WikimatchCandidateOptionNarrowingResponse, WikimatchCandidateOptionNarrowingResult, WikimatchConflictGroup, WikimatchPolicyContinuation, WikimatchPolicyDecision, WikimatchPolicyDecisionOutput, WikimatchPolicyFallback, WikimatchPolicyGroupOutput, WikimatchPolicyJudgeInput, WikimatchPolicyJudgeResult, WikimatchPolicyResponse, WikimatchPolicyUpdate, WikimatchProtectedSurface, WikimatchProtectedSurfaceOutput, WikimatchQidOption, WikimatchSentence, WikimatchSurface, WikimatchSurfaceProtectionBuildResult, WikimatchSurfaceProtectionFallback, WikimatchSurfaceProtectionInput, WikimatchSurfaceProtectionResponse, WikimatchSurfaceProtectionResult, WikimatchTextRange, WikimatchWindow };

package/dist/wikimatch/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/wikimatch/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/wikimatch/wikispine.d.ts

@@ -0,0 +1,43 @@
+import { WikimatchSentence, WikimatchCandidate } from './types.js';
+import '../wikipage/types.js';
+
+interface MatchWikispineSentenceCandidatesOptions {
+    readonly command?: string;
+    readonly dataDir?: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof fetch;
+    readonly includeDisambiguation?: boolean;
+    readonly maxCandidatesPerSurface?: number;
+    readonly onProgress?: (progress: WikispineMatchProgress) => Promise<void> | void;
+    readonly provider?: WikispineProvider;
+    readonly sentences: readonly WikimatchSentence[];
+}
+type WikispineProvider = "cli" | "fetch";
+interface WikispineMatchProgress {
+    readonly coveredRangeEnd: number;
+}
+interface TestWikispineRuntimeOptions {
+    readonly command?: string;
+    readonly dataDir?: string;
+    readonly endpoint?: string;
+    readonly fetch?: typeof fetch;
+    readonly provider?: WikispineProvider;
+}
+interface WikispineRuntimeTestResult {
+    readonly durationMs: number;
+    readonly metadata?: WikispineMetadata;
+    readonly ok: true;
+    readonly provider: WikispineProvider;
+}
+interface WikispineMetadata {
+    readonly automaton_shard_count: number;
+    readonly format: string;
+    readonly qid_count: number;
+    readonly surface_count: number;
+    readonly surface_normalization: string;
+}
+declare const DEFAULT_WIKISPINE_FETCH_ENDPOINT = "https://wikispi-service-cxbfjlteab.cn-hangzhou.fcapp.run";
+declare function matchWikispineSentenceCandidates(options: MatchWikispineSentenceCandidatesOptions): Promise<readonly WikimatchCandidate[]>;
+declare function testWikispineRuntime(options: TestWikispineRuntimeOptions): Promise<WikispineRuntimeTestResult>;
+
+export { DEFAULT_WIKISPINE_FETCH_ENDPOINT, type MatchWikispineSentenceCandidatesOptions, type TestWikispineRuntimeOptions, type WikispineMatchProgress, type WikispineProvider, type WikispineRuntimeTestResult, matchWikispineSentenceCandidates, testWikispineRuntime };