@aeptus/aexeo-emdash 0.1.0

package/dist/configured.js

@@ -0,0 +1,661 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/adapter.ts
+function contentItemToEmdashDocument(content) {
+  const route = deriveRoute(content);
+  const title = stringOrEmpty(
+    content.seo?.title ?? content.data["title"] ?? content.slug ?? content.id
+  );
+  const document = {
+    route,
+    title
+  };
+  const description = content.seo?.description ?? content.data["description"];
+  if (typeof description === "string" && description.length > 0) {
+    document.description = description;
+  }
+  const canonical = content.seo?.canonical;
+  if (typeof canonical === "string" && canonical.length > 0) {
+    document.canonical = canonical;
+  }
+  if (content.locale !== null) {
+    document.lang = content.locale;
+  }
+  const body = extractPortableText(content.data);
+  if (body !== null) {
+    document.body = body;
+  }
+  return document;
+}
+function deriveRoute(content) {
+  if (typeof content.slug === "string" && content.slug.length > 0) {
+    return content.slug.startsWith("/") ? content.slug : `/${content.slug}`;
+  }
+  return `/${content.type}/${content.id}`;
+}
+function stringOrEmpty(value) {
+  return typeof value === "string" ? value : "";
+}
+function extractPortableText(data) {
+  const candidates = ["body", "content"];
+  for (const slug of candidates) {
+    const value = data[slug];
+    if (isPortableTextArray(value)) {
+      return value;
+    }
+  }
+  for (const value of Object.values(data)) {
+    if (isPortableTextArray(value)) {
+      return value;
+    }
+  }
+  return null;
+}
+function isPortableTextArray(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    return false;
+  }
+  const first = value[0];
+  return typeof first === "object" && first !== null && "_type" in first && typeof first._type === "string";
+}
+
+// src/plugin.ts
+async function handleAfterSaveConfigured(event, ctx, evaluator) {
+  const document = contentItemToEmdashDocument(event.content);
+  const { kv, log } = ctx;
+  await kv.set(documentKey(document.route), document);
+  const result = await evaluator([document]);
+  if (!result.ok) {
+    log?.error?.(`afterSave evaluator failure (${result.reason})`, {
+      detail: result.detail
+    });
+    return;
+  }
+  const pageFindings = result.findings.filter(
+    (finding) => finding.scope === "page"
+  );
+  await kv.set(findingsKey(document.route), {
+    route: document.route,
+    findings: pageFindings
+  });
+}
+var DEFAULT_COLLECTIONS = ["posts", "pages"];
+async function evaluateAndPersistAll(ctx, options) {
+  const collections = options.collections ?? DEFAULT_COLLECTIONS;
+  const { kv, log } = ctx;
+  const summary = {
+    documentsScanned: 0,
+    routesUpdated: 0,
+    totalFindings: 0,
+    errors: []
+  };
+  const documents = [];
+  const documentRoutes = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    let cursor;
+    do {
+      try {
+        const page = await ctx.content.list(collection, {
+          limit: 100,
+          ...cursor === void 0 ? {} : { cursor }
+        });
+        for (const item of page.items) {
+          const document = contentItemToEmdashDocument(item);
+          documents.push(document);
+          documentRoutes.add(document.route);
+        }
+        cursor = page.hasMore ? page.cursor : void 0;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        summary.errors.push(`${collection}: ${message}`);
+        cursor = void 0;
+      }
+    } while (cursor !== void 0);
+  }
+  summary.documentsScanned = documents.length;
+  for (const document of documents) {
+    await kv.set(documentKey(document.route), document);
+  }
+  const result = await options.evaluator(documents);
+  if (!result.ok) {
+    log?.error?.(`seogeo evaluator failure (${result.reason})`, {
+      detail: result.detail
+    });
+    summary.errors.push(`${result.reason}: ${result.detail}`);
+    return summary;
+  }
+  const findingsByRoute = /* @__PURE__ */ new Map();
+  for (const route of documentRoutes) {
+    findingsByRoute.set(route, []);
+  }
+  for (const finding of result.findings) {
+    const bucket = finding.scope === "page" ? finding.path : "*";
+    const list = findingsByRoute.get(bucket) ?? [];
+    list.push(finding);
+    findingsByRoute.set(bucket, list);
+  }
+  for (const [route, findings] of findingsByRoute) {
+    await kv.set(findingsKey(route), { route, findings });
+    summary.routesUpdated += 1;
+  }
+  summary.totalFindings = result.findings.length;
+  return summary;
+}
+function findingsKey(route) {
+  const normalized = route === "" || route === "/" ? "/" : route;
+  return `findings:${normalized}`;
+}
+function documentKey(route) {
+  const normalized = route === "" || route === "/" ? "/" : route;
+  return `document:${normalized}`;
+}
+async function readAllDocuments(kv) {
+  const entries = await kv.list("document:");
+  return entries.map((entry) => entry.value).filter((value) => value !== null);
+}
+async function readFindings(kv, route) {
+  const stored = await kv.get(findingsKey(route));
+  if (stored === null) {
+    return [];
+  }
+  return stored.findings;
+}
+
+// wasm/aexeo_emdash_bridge_bg.js
+var aexeo_emdash_bridge_bg_exports = {};
+__export(aexeo_emdash_bridge_bg_exports, {
+  __wbg_Error_960c155d3d49e4c2: () => __wbg_Error_960c155d3d49e4c2,
+  __wbg_set_wasm: () => __wbg_set_wasm,
+  __wbindgen_init_externref_table: () => __wbindgen_init_externref_table,
+  evaluateDocuments: () => evaluateDocuments,
+  scoreIntelligence: () => scoreIntelligence
+});
+function evaluateDocuments(documents_json, config_json) {
+  let deferred4_0;
+  let deferred4_1;
+  try {
+    const ptr0 = passStringToWasm0(documents_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(config_json) ? 0 : passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.evaluateDocuments(ptr0, len0, ptr1, len1);
+    var ptr3 = ret[0];
+    var len3 = ret[1];
+    if (ret[3]) {
+      ptr3 = 0;
+      len3 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred4_0 = ptr3;
+    deferred4_1 = len3;
+    return getStringFromWasm0(ptr3, len3);
+  } finally {
+    wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+  }
+}
+function scoreIntelligence(documents_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(documents_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.scoreIntelligence(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+function __wbg_Error_960c155d3d49e4c2(arg0, arg1) {
+  const ret = Error(getStringFromWasm0(arg0, arg1));
+  return ret;
+}
+function __wbindgen_init_externref_table() {
+  const table = wasm.__wbindgen_externrefs;
+  const offset = table.grow(4);
+  table.set(0, void 0);
+  table.set(offset + 0, void 0);
+  table.set(offset + 1, null);
+  table.set(offset + 2, true);
+  table.set(offset + 3, false);
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasm;
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+
+// src/wasm-init.ts
+import bridgeModule from "../wasm/aexeo_emdash_bridge_bg.wasm";
+var initialized = false;
+function ensureInitialized() {
+  if (initialized) {
+    return;
+  }
+  if (!(bridgeModule instanceof WebAssembly.Module)) {
+    throw new Error(
+      "seogeo: WASM module did not resolve to a WebAssembly.Module \u2014 the consumer's bundler isn't configured for .wasm imports. Add the .wasm loader to your Vite/wrangler config; see @aeptus/aexeo-emdash INSTALL.md for the recipe."
+    );
+  }
+  const instance = new WebAssembly.Instance(bridgeModule, {
+    "./aexeo_emdash_bridge_bg.js": aexeo_emdash_bridge_bg_exports
+  });
+  __wbg_set_wasm(instance.exports);
+  instance.exports.__wbindgen_start();
+  initialized = true;
+}
+async function evaluateDocuments2(documentsJson, configJson) {
+  ensureInitialized();
+  return evaluateDocuments(documentsJson, configJson);
+}
+async function scoreIntelligence2(documentsJson) {
+  ensureInitialized();
+  return scoreIntelligence(documentsJson);
+}
+
+// src/configured.ts
+import { definePlugin } from "emdash";
+var inProcessEvaluator = async (documents) => {
+  try {
+    const raw = await evaluateDocuments2(JSON.stringify(documents));
+    const findings = JSON.parse(raw);
+    if (!Array.isArray(findings)) {
+      return {
+        ok: false,
+        reason: "invalid_response",
+        detail: "WASM returned non-array body"
+      };
+    }
+    return { ok: true, findings };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: "wasm_error", detail };
+  }
+};
+function createPlugin(_options = {}) {
+  return definePlugin({
+    id: "aexeo-seogeo",
+    version: "0.0.1",
+    capabilities: ["read:content"],
+    hooks: {
+      "content:afterSave": (event, ctx) => handleAfterSaveConfigured(event, ctx, inProcessEvaluator)
+    },
+    routes: {
+      admin: { handler: handleAdminRoute }
+    },
+    admin: {
+      pages: [
+        // emdash's /admin/plugins/<id> root navigates to the plugin's
+        // "/" page — without it, clicking the plugin in the meta list
+        // produces a "Not Found". Alias "/" to the findings page so
+        // the entry-point lands somewhere useful.
+        { path: "/", label: "SEO findings" },
+        { path: "/findings", label: "SEO findings" },
+        { path: "/document", label: "Document SEO" }
+      ],
+      widgets: [
+        { id: "seogeo-score", size: "third", title: "SEO score" }
+      ]
+    }
+  });
+}
+var configured_default = createPlugin;
+async function handleAdminRoute(ctx) {
+  const body = ctx.input;
+  if (body.type === "page_load") {
+    return handlePageLoad(ctx, body.page);
+  }
+  if (body.type === "block_action") {
+    if (body.action_id === "view_document" && typeof body.value === "string") {
+      return renderDocumentPanel(ctx, body.value);
+    }
+    if (body.action_id === "refresh_findings") {
+      return handleRefresh(ctx);
+    }
+    if (body.action_id.startsWith("filter:")) {
+      return renderFindingsPage(ctx);
+    }
+    return notFound(body.action_id);
+  }
+  if (body.type === "form_submit") {
+    if (body.action_id === "view_document") {
+      const picked = body.values["route_picker"];
+      if (typeof picked === "string" && picked.length > 0) {
+        return renderDocumentPanel(ctx, picked);
+      }
+    }
+    return renderFindingsPage(ctx);
+  }
+  return renderFindingsPage(ctx);
+}
+async function handlePageLoad(ctx, page) {
+  const normalized = page.startsWith("/") ? page.slice(1) : page;
+  if (normalized === "" || normalized === "findings") {
+    return renderFindingsPage(ctx);
+  }
+  if (normalized === "widget:seogeo-score") {
+    return renderScoreWidget(ctx);
+  }
+  if (normalized === "document") {
+    return renderDocumentPanel(ctx);
+  }
+  return notFound(page);
+}
+async function handleRefresh(ctx) {
+  let summary;
+  try {
+    summary = await evaluateAndPersistAll(ctx, {
+      evaluator: inProcessEvaluator
+    });
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      blocks: [
+        { type: "header", text: "SEO findings" },
+        {
+          type: "banner",
+          title: `Refresh failed: ${detail}`,
+          variant: "error"
+        }
+      ],
+      toast: { message: `Refresh failed: ${detail}`, type: "error" }
+    };
+  }
+  const refreshed = await renderFindingsPage(ctx);
+  const toastMessage = summary.errors.length === 0 ? `Refreshed ${summary.routesUpdated} routes (${summary.totalFindings} findings across ${summary.documentsScanned} documents)` : `Refresh completed with ${summary.errors.length} errors \u2014 see banner`;
+  if (summary.errors.length > 0) {
+    refreshed.blocks.unshift({
+      type: "banner",
+      title: `Refresh issues: ${summary.errors.join(" \u2022 ")}`,
+      variant: "alert"
+    });
+  }
+  return {
+    ...refreshed,
+    toast: {
+      message: toastMessage,
+      type: summary.errors.length === 0 ? "success" : "info"
+    }
+  };
+}
+async function readAllFindings(ctx) {
+  const entries = await ctx.kv.list(
+    "findings:"
+  );
+  const out = [];
+  for (const entry of entries) {
+    if (entry.value === null) continue;
+    const route = entry.key.replace(/^findings:/, "");
+    for (const finding of entry.value.findings) {
+      out.push({ ...finding, document_route: route });
+    }
+  }
+  return out;
+}
+function severityFirst(a, b) {
+  const rank = (severity) => severity === "error" ? 0 : 1;
+  const diff = rank(a.severity) - rank(b.severity);
+  if (diff !== 0) return diff;
+  return a.rule_id.localeCompare(b.rule_id);
+}
+function uniqueRoutes(rows) {
+  const set = /* @__PURE__ */ new Set();
+  for (const row of rows) set.add(row.document_route);
+  return [...set].sort();
+}
+async function renderFindingsPage(ctx) {
+  const findings = await readAllFindings(ctx);
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const sorted = [...findings].sort(severityFirst);
+  const routes = uniqueRoutes(findings);
+  const blocks = [
+    { type: "header", text: "SEO findings" },
+    {
+      type: "context",
+      text: findings.length === 0 ? "No findings yet \u2014 click Refresh to evaluate the site." : `${findings.length} findings across ${routes.length} routes \u2014 ${errors.length} errors, ${warnings.length} warnings.`
+    },
+    { type: "divider" },
+    {
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          label: "Refresh",
+          action_id: "refresh_findings",
+          style: "primary"
+        },
+        { type: "button", label: "All", action_id: "filter:all" },
+        { type: "button", label: "Errors only", action_id: "filter:errors" },
+        {
+          type: "button",
+          label: "Warnings only",
+          action_id: "filter:warnings"
+        }
+      ]
+    },
+    sorted.length === 0 ? {
+      type: "context",
+      text: "Once a Refresh runs, findings will list here."
+    } : findingsTable(sorted)
+  ];
+  if (routes.length > 0) {
+    blocks.push({
+      type: "form",
+      fields: [
+        {
+          type: "select",
+          action_id: "route_picker",
+          label: "Document to inspect",
+          options: routes.map((route) => ({ label: route, value: route }))
+        }
+      ],
+      submit: { label: "View document SEO", action_id: "view_document" }
+    });
+  }
+  return { blocks };
+}
+function findingsTable(rows) {
+  return {
+    type: "table",
+    columns: [
+      { key: "route", label: "Route" },
+      { key: "rule", label: "Rule", format: "code" },
+      { key: "severity", label: "Severity", format: "badge" },
+      { key: "message", label: "Message" }
+    ],
+    rows: rows.map((row) => ({
+      route: row.document_route,
+      rule: row.rule_id,
+      severity: row.severity,
+      message: row.message
+    }))
+  };
+}
+async function renderScoreWidget(ctx) {
+  const documents = await readAllDocuments(ctx.kv);
+  if (documents.length === 0) {
+    return {
+      blocks: [
+        { type: "header", text: "SEO score" },
+        {
+          type: "context",
+          text: "No documents indexed \u2014 click Refresh on the seogeo findings page."
+        }
+      ]
+    };
+  }
+  const score = await scoreLocally(documents);
+  const blocks = [
+    {
+      type: "stats",
+      items: [
+        { label: "Overall", value: `${score.overall_score}` },
+        { label: "Citation", value: `${score.citation_readiness_score}` },
+        { label: "Truth", value: `${score.truth_consistency_score}` },
+        { label: "Answers", value: `${score.answer_pack_score}` }
+      ]
+    }
+  ];
+  if (score.overall_score < 60) {
+    blocks.unshift({
+      type: "banner",
+      title: `Site score is ${score.overall_score} \u2014 below the 60 quality threshold`,
+      variant: "alert"
+    });
+  }
+  if (score.blockers.length > 0) {
+    blocks.push({ type: "context", text: topBlockersLine(score) });
+  }
+  return { blocks };
+}
+async function scoreLocally(documents) {
+  const raw = await scoreIntelligence2(JSON.stringify(documents));
+  return JSON.parse(raw);
+}
+function topBlockersLine(score) {
+  const top = score.blockers.slice(0, 3).map((b) => b.message);
+  if (top.length === 0) return "No blockers identified.";
+  return `Top blockers: ${top.join(" \u2022 ")}`;
+}
+async function renderDocumentPanel(ctx, route) {
+  if (route === void 0) {
+    return {
+      blocks: [
+        { type: "header", text: "Document SEO" },
+        {
+          type: "context",
+          text: "Pick a document from the SEO findings list to see its rule findings here."
+        }
+      ]
+    };
+  }
+  const findings = await readFindings(ctx.kv, route);
+  const errors = findings.filter((f) => f.severity === "error");
+  const warnings = findings.filter((f) => f.severity === "warning");
+  const sorted = [...findings].sort(severityFirst);
+  return {
+    blocks: [
+      { type: "header", text: `Document SEO \u2014 ${route}` },
+      {
+        type: "context",
+        text: findings.length === 0 ? `No findings for ${route} \u2014 the document is currently clean.` : `${findings.length} findings \u2014 ${errors.length} errors, ${warnings.length} warnings.`
+      },
+      ...findings.length === 0 ? [] : [{ type: "divider" }, documentFindingsTable(sorted)]
+    ]
+  };
+}
+function documentFindingsTable(findings) {
+  return {
+    type: "table",
+    columns: [
+      { key: "rule", label: "Rule", format: "code" },
+      { key: "severity", label: "Severity", format: "badge" },
+      { key: "message", label: "Message" },
+      { key: "block", label: "Block", format: "code" }
+    ],
+    rows: findings.map((finding) => ({
+      rule: finding.rule_id,
+      severity: finding.severity,
+      message: finding.message,
+      block: `${finding.path}:${finding.line}`
+    }))
+  };
+}
+function notFound(page) {
+  return {
+    blocks: [
+      { type: "header", text: "Not found" },
+      { type: "context", text: `unknown page: ${page}` }
+    ]
+  };
+}
+export {
+  createPlugin,
+  configured_default as default
+};

package/dist/evaluator-sandbox.d.ts

@@ -0,0 +1,6 @@
+import type { EmdashDocument, Finding, SiteIntelligenceScore } from "./types.js";
+export declare function evaluate(_documents: readonly EmdashDocument[]): Promise<Finding[]>;
+export declare function scoreSite(_documents: readonly EmdashDocument[]): Promise<SiteIntelligenceScore>;
+export declare function errorFindings(findings: readonly Finding[]): Finding[];
+export declare function findingsByRoute(findings: readonly Finding[]): Map<string, Finding[]>;
+//# sourceMappingURL=evaluator-sandbox.d.ts.map

package/dist/evaluator-sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator-sandbox.d.ts","sourceRoot":"","sources":["../src/evaluator-sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,OAAO,EACP,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAkBpB,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,SAAS,cAAc,EAAE,GACpC,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,wBAAsB,SAAS,CAC7B,UAAU,EAAE,SAAS,cAAc,EAAE,GACpC,OAAO,CAAC,qBAAqB,CAAC,CAUhC;AAQD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAErE;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAWxB"}

package/dist/evaluator.d.ts

@@ -0,0 +1,9 @@
+import type { EmdashDocument, Finding, SiteIntelligenceScore } from "./types.js";
+export interface EvaluateOptions {
+    configJson?: string;
+}
+export declare function evaluate(documents: readonly EmdashDocument[], options?: EvaluateOptions): Promise<Finding[]>;
+export declare function errorFindings(findings: readonly Finding[]): Finding[];
+export declare function findingsByRoute(findings: readonly Finding[]): Map<string, Finding[]>;
+export declare function scoreSite(documents: readonly EmdashDocument[]): Promise<SiteIntelligenceScore>;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../src/evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,OAAO,EACP,qBAAqB,EACtB,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,eAAe;IAG9B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,QAAQ,CAC5B,SAAS,EAAE,SAAS,cAAc,EAAE,EACpC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,OAAO,EAAE,CAAC,CAIpB;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAErE;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAWxB;AAKD,wBAAsB,SAAS,CAC7B,SAAS,EAAE,SAAS,cAAc,EAAE,GACnC,OAAO,CAAC,qBAAqB,CAAC,CAGhC"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { seogeoPluginSandboxed } from "./sandbox.js";
+export type { PluginAdminPage, PluginAdminWidget, SandboxedPluginDescriptor, SeogeoSandboxedOptions, } from "./sandbox.js";
+export interface ConfiguredPluginDescriptor {
+    id: string;
+    version: string;
+    entrypoint: string;
+    options: Record<string, unknown>;
+    capabilities: readonly string[];
+    allowedHosts?: readonly string[];
+    adminPages: readonly {
+        path: string;
+        label: string;
+    }[];
+    adminWidgets: readonly {
+        id: string;
+        size?: string;
+        title?: string;
+    }[];
+}
+export interface SeogeoPluginOptions {
+}
+export declare function seogeoPlugin(options?: SeogeoPluginOptions): ConfiguredPluginDescriptor;
+//# sourceMappingURL=index.d.ts.map