@ashdev/codex-plugin-release-nyaa 1.18.0

package/dist/index.js

@@ -0,0 +1,1433 @@
+#!/usr/bin/env node
+
+// ../sdk-typescript/dist/types/rpc.js
+var JSON_RPC_ERROR_CODES = {
+  /** Invalid JSON was received */
+  PARSE_ERROR: -32700,
+  /** The JSON sent is not a valid Request object */
+  INVALID_REQUEST: -32600,
+  /** The method does not exist / is not available */
+  METHOD_NOT_FOUND: -32601,
+  /** Invalid method parameter(s) */
+  INVALID_PARAMS: -32602,
+  /** Internal JSON-RPC error */
+  INTERNAL_ERROR: -32603
+};
+
+// ../sdk-typescript/dist/errors.js
+var PluginError = class extends Error {
+  data;
+  constructor(message, data) {
+    super(message);
+    this.name = this.constructor.name;
+    this.data = data;
+  }
+  /**
+   * Convert to JSON-RPC error format
+   */
+  toJsonRpcError() {
+    return {
+      code: this.code,
+      message: this.message,
+      data: this.data
+    };
+  }
+};
+
+// ../sdk-typescript/dist/request-context.js
+import { AsyncLocalStorage } from "node:async_hooks";
+var store = new AsyncLocalStorage();
+function runWithParentRequestId(forwardRequestId, fn) {
+  return store.run(forwardRequestId, fn);
+}
+function currentParentRequestId() {
+  return store.getStore();
+}
+
+// ../sdk-typescript/dist/host-rpc.js
+var HostRpcError = class extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "HostRpcError";
+  }
+};
+var HostRpcClient = class {
+  // Start the counter high so it can't collide with PluginStorage's id space.
+  // `Number.MAX_SAFE_INTEGER` is far above this, so we have plenty of room
+  // before wrapping (and we never expect a single plugin lifetime to issue
+  // more than ~9 quintillion calls).
+  nextId = 1e9;
+  pendingRequests = /* @__PURE__ */ new Map();
+  writeFn;
+  /**
+   * @param writeFn - Optional custom write function (defaults to
+   *   `process.stdout.write`). Useful for testing.
+   */
+  constructor(writeFn) {
+    this.writeFn = writeFn ?? ((line) => {
+      process.stdout.write(line);
+    });
+  }
+  /**
+   * Send a JSON-RPC request to the host and resolve with the result.
+   *
+   * @param method - JSON-RPC method name (e.g. `"releases/list_tracked"`).
+   * @param params - Method-specific params. Pass `undefined` when the method
+   *   takes no params.
+   */
+  async call(method, params) {
+    const id = this.nextId++;
+    const parent = currentParentRequestId();
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params,
+      ...parent !== void 0 ? { parentRequestId: parent } : {}
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, {
+        resolve: (v) => resolve(v),
+        reject
+      });
+      try {
+        this.writeFn(`${JSON.stringify(request)}
+`);
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        const message = err instanceof Error ? err.message : "Unknown write error";
+        reject(new HostRpcError(`Failed to send request: ${message}`, -1));
+      }
+    });
+  }
+  /**
+   * Process an incoming JSON-RPC response line. Returns `true` if this
+   * client owned the response id and resolved it, `false` otherwise (so
+   * other clients can try).
+   *
+   * Called by the plugin server's main loop on every response.
+   */
+  handleResponse(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return false;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return false;
+    }
+    const obj = parsed;
+    if (obj.method !== void 0)
+      return false;
+    const rawId = obj.id;
+    if (typeof rawId !== "number")
+      return false;
+    if (!this.pendingRequests.has(rawId))
+      return false;
+    const pending = this.pendingRequests.get(rawId);
+    if (!pending)
+      return false;
+    this.pendingRequests.delete(rawId);
+    if ("error" in obj && obj.error) {
+      const err = obj.error;
+      pending.reject(new HostRpcError(err.message, err.code, err.data));
+    } else {
+      pending.resolve(obj.result);
+    }
+    return true;
+  }
+  /** Reject all pending requests (e.g. on shutdown). */
+  cancelAll() {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new HostRpcError("Host RPC client stopped", -1));
+    }
+    this.pendingRequests.clear();
+  }
+};
+
+// ../sdk-typescript/dist/logger.js
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  name;
+  minLevel;
+  timestamps;
+  constructor(options) {
+    this.name = options.name;
+    this.minLevel = LOG_LEVELS[options.level ?? "info"];
+    this.timestamps = options.timestamps ?? true;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= this.minLevel;
+  }
+  format(level, message, data) {
+    const parts = [];
+    if (this.timestamps) {
+      parts.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    parts.push(`[${level.toUpperCase()}]`);
+    parts.push(`[${this.name}]`);
+    parts.push(message);
+    if (data !== void 0) {
+      if (data instanceof Error) {
+        parts.push(`- ${data.message}`);
+        if (data.stack) {
+          parts.push(`
+${data.stack}`);
+        }
+      } else if (typeof data === "object") {
+        parts.push(`- ${JSON.stringify(data)}`);
+      } else {
+        parts.push(`- ${String(data)}`);
+      }
+    }
+    return parts.join(" ");
+  }
+  log(level, message, data) {
+    if (this.shouldLog(level)) {
+      process.stderr.write(`${this.format(level, message, data)}
+`);
+    }
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+// ../sdk-typescript/dist/server.js
+import { createInterface } from "node:readline";
+
+// ../sdk-typescript/dist/storage.js
+var StorageError = class extends Error {
+  code;
+  data;
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "StorageError";
+  }
+};
+var PluginStorage = class {
+  nextId = 1;
+  pendingRequests = /* @__PURE__ */ new Map();
+  writeFn;
+  /**
+   * Create a new storage client.
+   *
+   * @param writeFn - Optional custom write function (defaults to process.stdout.write).
+   *                  Useful for testing or custom transport layers.
+   */
+  constructor(writeFn) {
+    this.writeFn = writeFn ?? ((line) => {
+      process.stdout.write(line);
+    });
+  }
+  /**
+   * Get a value by key
+   *
+   * @param key - Storage key to retrieve
+   * @returns The stored data and optional expiration, or null data if key doesn't exist
+   */
+  async get(key) {
+    return await this.sendRequest("storage/get", { key });
+  }
+  /**
+   * Set a value by key (upsert - creates or updates)
+   *
+   * @param key - Storage key
+   * @param data - JSON-serializable data to store
+   * @param expiresAt - Optional expiration timestamp (ISO 8601)
+   * @returns Success indicator
+   */
+  async set(key, data, expiresAt) {
+    const params = { key, data };
+    if (expiresAt !== void 0) {
+      params.expiresAt = expiresAt;
+    }
+    return await this.sendRequest("storage/set", params);
+  }
+  /**
+   * Delete a value by key
+   *
+   * @param key - Storage key to delete
+   * @returns Whether the key existed and was deleted
+   */
+  async delete(key) {
+    return await this.sendRequest("storage/delete", { key });
+  }
+  /**
+   * List all keys for this plugin instance (excluding expired)
+   *
+   * @returns List of key entries with metadata
+   */
+  async list() {
+    return await this.sendRequest("storage/list", {});
+  }
+  /**
+   * Clear all data for this plugin instance
+   *
+   * @returns Number of entries deleted
+   */
+  async clear() {
+    return await this.sendRequest("storage/clear", {});
+  }
+  /**
+   * Handle an incoming JSON-RPC response line from the host.
+   *
+   * Call this method from your readline handler to deliver responses
+   * back to pending storage requests.
+   */
+  handleResponse(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const obj = parsed;
+    if (obj.method !== void 0) {
+      return;
+    }
+    const id = obj.id;
+    if (id === void 0 || id === null)
+      return;
+    const pending = this.pendingRequests.get(id);
+    if (!pending)
+      return;
+    this.pendingRequests.delete(id);
+    if ("error" in obj && obj.error) {
+      const err = obj.error;
+      pending.reject(new StorageError(err.message, err.code, err.data));
+    } else {
+      pending.resolve(obj.result);
+    }
+  }
+  /**
+   * Cancel all pending requests (e.g. on shutdown).
+   */
+  cancelAll() {
+    for (const [, pending] of this.pendingRequests) {
+      pending.reject(new StorageError("Storage client stopped", -1));
+    }
+    this.pendingRequests.clear();
+  }
+  // ===========================================================================
+  // Internal
+  // ===========================================================================
+  sendRequest(method, params) {
+    const id = this.nextId++;
+    const request = {
+      jsonrpc: "2.0",
+      id,
+      method,
+      params
+    };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      try {
+        this.writeFn(`${JSON.stringify(request)}
+`);
+      } catch (err) {
+        this.pendingRequests.delete(id);
+        const message = err instanceof Error ? err.message : "Unknown write error";
+        reject(new StorageError(`Failed to send request: ${message}`, -1));
+      }
+    });
+  }
+};
+
+// ../sdk-typescript/dist/server.js
+function validateStringFields(params, fields) {
+  if (params === null || params === void 0) {
+    return { field: "params", message: "params is required" };
+  }
+  if (typeof params !== "object") {
+    return { field: "params", message: "params must be an object" };
+  }
+  const obj = params;
+  for (const field of fields) {
+    const value = obj[field];
+    if (value === void 0 || value === null) {
+      return { field, message: `${field} is required` };
+    }
+    if (typeof value !== "string") {
+      return { field, message: `${field} must be a string` };
+    }
+    if (value.trim() === "") {
+      return { field, message: `${field} cannot be empty` };
+    }
+  }
+  return null;
+}
+function invalidParamsError(id, error) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+      message: `Invalid params: ${error.message}`,
+      data: { field: error.field }
+    }
+  };
+}
+function createPluginServer(options) {
+  const { manifest: manifest2, onInitialize, logLevel = "info", label, router } = options;
+  const logger2 = createLogger({ name: manifest2.name, level: logLevel });
+  const prefix = label ? `${label} plugin` : "plugin";
+  const storage = new PluginStorage();
+  const hostRpc = new HostRpcClient();
+  logger2.info(`Starting ${prefix}: ${manifest2.displayName} v${manifest2.version}`);
+  const rl = createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  rl.on("line", (line) => {
+    void handleLine(line, manifest2, onInitialize, router, logger2, storage, hostRpc);
+  });
+  rl.on("close", () => {
+    logger2.info("stdin closed, shutting down");
+    storage.cancelAll();
+    hostRpc.cancelAll();
+    process.exit(0);
+  });
+  process.on("uncaughtException", (error) => {
+    logger2.error("Uncaught exception", error);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger2.error("Unhandled rejection", reason);
+  });
+}
+function isJsonRpcResponse(obj) {
+  if (obj.method !== void 0)
+    return false;
+  if (obj.id === void 0 || obj.id === null)
+    return false;
+  return "result" in obj || "error" in obj;
+}
+async function handleLine(line, manifest2, onInitialize, router, logger2, storage, hostRpc) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+  }
+  if (parsed && isJsonRpcResponse(parsed)) {
+    logger2.debug("Routing reverse-RPC response", { id: parsed.id });
+    if (!hostRpc.handleResponse(trimmed)) {
+      storage.handleResponse(trimmed);
+    }
+    return;
+  }
+  let id = null;
+  try {
+    const request = parsed ?? JSON.parse(trimmed);
+    id = request.id;
+    logger2.debug(`Received request: ${request.method}`, { id: request.id });
+    const response = await runWithParentRequestId(request.id, () => handleRequest(request, manifest2, onInitialize, router, logger2, storage, hostRpc));
+    if (response !== null) {
+      writeResponse(response);
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
+          message: "Parse error: invalid JSON"
+        }
+      });
+    } else if (error instanceof PluginError) {
+      writeResponse({
+        jsonrpc: "2.0",
+        id,
+        error: error.toJsonRpcError()
+      });
+    } else {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger2.error("Request failed", error);
+      writeResponse({
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+          message
+        }
+      });
+    }
+  }
+}
+async function handleRequest(request, manifest2, onInitialize, router, logger2, storage, hostRpc) {
+  const { method, params, id } = request;
+  switch (method) {
+    case "initialize": {
+      const initParams = params ?? {};
+      initParams.storage = storage;
+      initParams.hostRpc = hostRpc;
+      if (onInitialize) {
+        await onInitialize(initParams);
+      }
+      return { jsonrpc: "2.0", id, result: manifest2 };
+    }
+    case "ping":
+      return { jsonrpc: "2.0", id, result: "pong" };
+    case "shutdown": {
+      logger2.info("Shutdown requested");
+      storage.cancelAll();
+      hostRpc.cancelAll();
+      const response2 = { jsonrpc: "2.0", id, result: null };
+      process.stdout.write(`${JSON.stringify(response2)}
+`, () => {
+        process.exit(0);
+      });
+      return null;
+    }
+  }
+  const response = await router(method, params, id);
+  if (response !== null) {
+    return response;
+  }
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+      message: `Method not found: ${method}`
+    }
+  };
+}
+function writeResponse(response) {
+  process.stdout.write(`${JSON.stringify(response)}
+`);
+}
+function success(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function validateReleasePollParams(params) {
+  return validateStringFields(params, ["sourceId"]);
+}
+function createReleaseSourcePlugin(options) {
+  const { manifest: manifest2, provider, onInitialize, logLevel } = options;
+  if (!manifest2.capabilities.releaseSource) {
+    throw new Error("manifest.capabilities.releaseSource is required for createReleaseSourcePlugin");
+  }
+  const router = async (method, params, id) => {
+    switch (method) {
+      case "releases/poll": {
+        const err = validateReleasePollParams(params);
+        if (err)
+          return invalidParamsError(id, err);
+        return success(id, await provider.poll(params));
+      }
+      default:
+        return null;
+    }
+  };
+  createPluginServer({ manifest: manifest2, onInitialize, logLevel, label: "release-source", router });
+}
+
+// ../sdk-typescript/dist/types/releases.js
+var RELEASES_METHODS = {
+  /** List tracked series, scoped to what the plugin's manifest declared. */
+  LIST_TRACKED: "releases/list_tracked",
+  /** Submit a candidate to the host's release ledger. */
+  RECORD: "releases/record",
+  /** Get persisted per-source state (etag, last_polled_at, last_error). */
+  SOURCE_STATE_GET: "releases/source_state/get",
+  /** Set persisted per-source state (etag only — other fields are host-owned). */
+  SOURCE_STATE_SET: "releases/source_state/set",
+  /**
+   * Replace the set of `release_sources` rows owned by this plugin.
+   *
+   * Plugins call this from `onInitialize` (and after any config change, which
+   * triggers a process restart that re-runs `onInitialize`). Each call carries
+   * the plugin's full desired-state list; the host upserts every entry on
+   * `(plugin_id, source_key)` and prunes rows whose `source_key` is not in
+   * the request. User-managed fields (`enabled`, `pollIntervalS`) are
+   * preserved across re-registrations so an admin's overrides aren't
+   * trampled by a plugin restart.
+   */
+  REGISTER_SOURCES: "releases/register_sources"
+};
+
+// src/fetcher.ts
+var NYAA_BASE_URL = "https://nyaa.si";
+var PARAMS_ALLOWLIST = /* @__PURE__ */ new Set(["q", "c", "f", "u"]);
+function parseUrlParams(body) {
+  const params = new URLSearchParams(body);
+  const kept = [];
+  for (const [rawKey, rawValue] of params.entries()) {
+    const key = rawKey.toLowerCase();
+    if (!PARAMS_ALLOWLIST.has(key)) continue;
+    const value = rawValue.trim();
+    if (value.length === 0) continue;
+    kept.push([key, value]);
+  }
+  if (kept.length === 0) return null;
+  if (kept.length === 1 && kept[0]?.[0] === "u") {
+    return { kind: "user", identifier: kept[0][1] };
+  }
+  kept.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  const normalized = new URLSearchParams(kept).toString();
+  return { kind: "params", identifier: normalized };
+}
+function parseSubscriptionToken(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return null;
+  const prefixMatch = trimmed.match(/^(q|query):(.*)$/i);
+  if (prefixMatch) {
+    const body = (prefixMatch[2] ?? "").trim();
+    if (body.length === 0) return null;
+    if (body.startsWith("?")) {
+      return parseUrlParams(body.slice(1));
+    }
+    return { kind: "query", identifier: body };
+  }
+  return { kind: "user", identifier: trimmed };
+}
+function subscriptionToSourceKey(sub) {
+  return `${sub.kind}:${sub.identifier.toLowerCase()}`;
+}
+function sourceKeyToSubscription(key) {
+  const idx = key.indexOf(":");
+  if (idx <= 0 || idx === key.length - 1) return null;
+  const kind = key.slice(0, idx);
+  const identifier = key.slice(idx + 1);
+  if (kind === "user" || kind === "query" || kind === "params") {
+    return { kind, identifier };
+  }
+  return null;
+}
+function parseSubscriptionList(raw) {
+  let tokens;
+  if (Array.isArray(raw)) {
+    tokens = raw.filter((t) => typeof t === "string");
+  } else if (typeof raw === "string") {
+    tokens = raw.split(",");
+  } else {
+    return [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const token of tokens) {
+    const sub = parseSubscriptionToken(token);
+    if (sub === null) continue;
+    const key = subscriptionToSourceKey(sub);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(sub);
+  }
+  return out;
+}
+function feedUrl(subscription, baseUrl = NYAA_BASE_URL) {
+  const base = baseUrl.replace(/\/+$/, "");
+  if (subscription.kind === "user") {
+    return `${base}/?page=rss&u=${encodeURIComponent(subscription.identifier)}`;
+  }
+  if (subscription.kind === "query") {
+    return `${base}/?page=rss&q=${encodeURIComponent(subscription.identifier)}`;
+  }
+  return `${base}/?page=rss&${subscription.identifier}`;
+}
+async function fetchSubscriptionFeed(subscription, previousEtag, previousLastModified, opts = {}) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const timeoutMs = opts.timeoutMs ?? 1e4;
+  const baseUrl = opts.baseUrl ?? NYAA_BASE_URL;
+  const url = feedUrl(subscription, baseUrl);
+  const headers = {
+    Accept: "application/rss+xml, application/xml;q=0.9, */*;q=0.5",
+    "User-Agent": "Codex-ReleaseTracker/1.0 (+https://github.com/AshDevFr/codex)"
+  };
+  if (previousEtag) {
+    headers["If-None-Match"] = previousEtag;
+  }
+  if (previousLastModified) {
+    headers["If-Modified-Since"] = previousLastModified;
+  }
+  const signal = AbortSignal.timeout(timeoutMs);
+  let resp;
+  try {
+    resp = await fetchImpl(url, { method: "GET", headers, signal });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown fetch error";
+    return { kind: "error", status: 0, message: msg };
+  }
+  if (resp.status === 304) {
+    return { kind: "notModified", status: 304 };
+  }
+  if (resp.status === 200) {
+    const body = await resp.text();
+    const etag = resp.headers.get("etag");
+    const lastModified = resp.headers.get("last-modified");
+    return { kind: "ok", body, etag, lastModified, status: 200 };
+  }
+  return {
+    kind: "error",
+    status: resp.status,
+    message: `upstream returned ${resp.status} ${resp.statusText}`
+  };
+}
+
+// package.json
+var package_default = {
+  name: "@ashdev/codex-plugin-release-nyaa",
+  version: "1.18.0",
+  description: "Nyaa.si uploader-feed release-source plugin for Codex - announces torrent releases for tracked series, filtered by an admin allowlist of trusted uploaders",
+  main: "dist/index.js",
+  bin: "dist/index.js",
+  type: "module",
+  files: [
+    "dist",
+    "README.md"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/AshDevFr/codex.git",
+    directory: "plugins/release-nyaa"
+  },
+  scripts: {
+    build: "esbuild src/index.ts --bundle --platform=node --target=node22 --format=esm --outfile=dist/index.js --sourcemap --banner:js='#!/usr/bin/env node'",
+    dev: "npm run build -- --watch",
+    clean: "rm -rf dist",
+    start: "node dist/index.js",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    typecheck: "tsc --noEmit",
+    test: "vitest run --passWithNoTests",
+    "test:watch": "vitest",
+    prepublishOnly: "npm run lint && npm run build"
+  },
+  keywords: [
+    "codex",
+    "plugin",
+    "nyaa",
+    "release-source",
+    "manga",
+    "torrent"
+  ],
+  author: "Codex",
+  license: "MIT",
+  engines: {
+    node: ">=22.0.0"
+  },
+  dependencies: {
+    "@ashdev/codex-plugin-sdk": "file:../sdk-typescript"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.4.4",
+    "@types/node": "^22.0.0",
+    esbuild: "^0.27.3",
+    typescript: "^5.9.3",
+    vitest: "^4.0.18"
+  }
+};
+
+// src/manifest.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_MIN_CONFIDENCE = 0.7;
+var manifest = {
+  name: "release-nyaa",
+  displayName: "Nyaa Releases",
+  version: package_default.version,
+  description: "Announces new chapter / volume torrents for tracked series via Nyaa.si uploader RSS feeds. Limited to an admin-configured uploader allowlist; matches via title aliases.",
+  author: "Codex",
+  homepage: "https://github.com/AshDevFr/codex",
+  protocolVersion: "1.1",
+  capabilities: {
+    releaseSource: {
+      kinds: ["rss-uploader"],
+      requiresAliases: true,
+      canAnnounceChapters: true,
+      canAnnounceVolumes: true
+    }
+  },
+  configSchema: {
+    description: "Nyaa plugin configuration. The plugin polls the listed uploaders' RSS feeds (or, for groups without a Nyaa account, a fallback search query) and emits release candidates only for tracked series whose aliases match the parsed title. Notification-only: Codex never downloads torrents.",
+    fields: [
+      {
+        key: "uploaders",
+        label: "Uploader Subscriptions",
+        description: "List of trusted uploader handles or queries. Each entry is one of: `username` (a Nyaa user feed); `q:<query>` (a plain site-wide search); or `q:?<params>` (URL-style allowlisted params: `q`, `c`, `f`, `u` \u2014 e.g. `q:?c=3_1&q=Berserk` to search the Literature \u2192 English-translated category). Accepts a JSON array (preferred) or a legacy comma-separated string. Confidence stays above the rejection threshold only for entries that match a tracked series alias.",
+        type: "string-array",
+        required: false,
+        default: [],
+        example: ["1r0n", "TankobonBlur", "q:LuminousScans", "q:?c=3_1&q=Berserk"]
+      },
+      {
+        key: "requestTimeoutMs",
+        label: "Request Timeout (ms)",
+        description: "How long to wait for a single Nyaa RSS fetch before giving up. Defaults to 10000 (10 seconds).",
+        type: "number",
+        required: false,
+        default: DEFAULT_REQUEST_TIMEOUT_MS
+      },
+      {
+        key: "baseUrl",
+        label: "Nyaa Base URL",
+        description: "Override the Nyaa base URL. Useful for mirrors or for tests. Defaults to https://nyaa.si.",
+        type: "string",
+        required: false,
+        default: "https://nyaa.si",
+        example: "https://nyaa.si"
+      }
+    ]
+  },
+  userDescription: "Watches Nyaa.si uploader feeds for new releases of tracked series. Matches by title alias \u2014 make sure your series' aliases (auto-populated from metadata or added manually in the Tracking panel) cover the way the uploader names them. Notification-only \u2014 Codex never downloads anything.",
+  adminSetupInstructions: "1. Set the **Uploaders** config field to a JSON array of entries (a comma-separated string is still accepted for backwards compatibility). Each entry is one of: `username` (a Nyaa user feed, e.g. `tsuna69`), `q:<query>` (a plain site-wide search, e.g. `q:LuminousScans`), or `q:?<params>` (URL-style search with allowlisted keys `q`, `c`, `f`, `u`, e.g. `q:?c=3_1&q=Berserk` for the English-translated Literature category). 2. Save. The plugin restarts and the host materializes one row per entry in **Settings \u2192 Release tracking** \u2014 that's where you flip rows on/off, override the poll interval, or hit *Poll now*. 3. Make sure tracked series have aliases that match how the uploader names releases (alternate spellings, romanizations, volume-range tags). The plugin auto-prunes rows when you remove an entry from the list and re-save, so the Release tracking table stays in sync with this list."
+};
+
+// src/matcher.ts
+var CONFIDENCE_EXACT = 0.95;
+var DEFAULT_FUZZY_FLOOR = 0.7;
+var MIN_DICE_RATIO = 0.85;
+function normalizeAlias(input) {
+  let out = "";
+  let lastWasSpace = false;
+  for (const ch of input) {
+    if (/[\p{L}\p{N}]/u.test(ch)) {
+      out += ch.toLowerCase();
+      lastWasSpace = false;
+    } else if (/\s/.test(ch) && out.length > 0 && !lastWasSpace) {
+      out += " ";
+      lastWasSpace = true;
+    }
+  }
+  return out.endsWith(" ") ? out.slice(0, -1) : out;
+}
+function diceRatio(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  if (a === b) return 1;
+  const bigramsA = bigrams(a);
+  const bigramsB = bigrams(b);
+  if (bigramsA.size === 0 || bigramsB.size === 0) return 0;
+  let intersection = 0;
+  for (const bg of bigramsA) {
+    if (bigramsB.has(bg)) intersection++;
+  }
+  return 2 * intersection / (bigramsA.size + bigramsB.size);
+}
+function bigrams(s) {
+  const out = /* @__PURE__ */ new Set();
+  const words = s.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length >= 2) {
+    for (let i = 0; i < words.length - 1; i++) {
+      out.add(`${words[i]} ${words[i + 1]}`);
+    }
+  }
+  const flat = s.replace(/\s+/g, "");
+  if (flat.length >= 2) {
+    for (let i = 0; i < flat.length - 1; i++) {
+      out.add(`#${flat.slice(i, i + 2)}`);
+    }
+  } else if (flat.length === 1) {
+    out.add(`#${flat}`);
+  }
+  return out;
+}
+function matchSeries(seriesGuess, candidates, opts = {}) {
+  const floor = opts.fuzzyFloor ?? DEFAULT_FUZZY_FLOOR;
+  const target = normalizeAlias(seriesGuess);
+  if (target.length === 0 || candidates.length === 0) return null;
+  for (const c of candidates) {
+    for (const alias of c.aliases) {
+      if (normalizeAlias(alias) === target) {
+        return {
+          seriesId: c.seriesId,
+          confidence: CONFIDENCE_EXACT,
+          reason: "alias-exact",
+          matchedAlias: alias
+        };
+      }
+    }
+  }
+  let best = null;
+  let bestRatio = 0;
+  for (const c of candidates) {
+    for (const alias of c.aliases) {
+      const ratio = diceRatio(target, normalizeAlias(alias));
+      if (ratio > bestRatio) {
+        bestRatio = ratio;
+        best = {
+          seriesId: c.seriesId,
+          confidence: 0,
+          reason: "alias-fuzzy",
+          matchedAlias: alias
+        };
+      }
+    }
+  }
+  if (best === null || bestRatio < MIN_DICE_RATIO) return null;
+  const ceiling = 0.85;
+  const span = 1 - MIN_DICE_RATIO;
+  const t = (bestRatio - MIN_DICE_RATIO) / span;
+  const confidence = floor + t * (ceiling - floor);
+  if (confidence < floor) return null;
+  best.confidence = Number(confidence.toFixed(4));
+  return best;
+}
+function matchSeriesAny(seriesGuesses, candidates, opts = {}) {
+  if (seriesGuesses.length === 0) return null;
+  let best = null;
+  for (const guess of seriesGuesses) {
+    const m = matchSeries(guess, candidates, opts);
+    if (m === null) continue;
+    if (best === null || m.confidence > best.confidence) {
+      best = m;
+    }
+  }
+  return best;
+}
+
+// src/parser.ts
+function decodeXmlText(raw) {
+  let s = raw.trim();
+  const cdataMatch = s.match(/^<!\[CDATA\[([\s\S]*?)]]>$/);
+  if (cdataMatch?.[1] !== void 0) {
+    s = cdataMatch[1];
+  }
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+}
+function extractTagText(xml, tag) {
+  const safeTag = tag.replace(/:/g, "\\:");
+  const re = new RegExp(`<${safeTag}[^>]*>([\\s\\S]*?)</${safeTag}>`, "i");
+  const m = xml.match(re);
+  if (!m?.[1]) return null;
+  return decodeXmlText(m[1]);
+}
+function splitItems(xml) {
+  const out = [];
+  const re = /<item\b[^>]*>([\s\S]*?)<\/item>/gi;
+  for (; ; ) {
+    const match = re.exec(xml);
+    if (match === null) break;
+    if (match[1] !== void 0) out.push(match[1]);
+  }
+  return out;
+}
+function extractLeadingGroup(title) {
+  const m = title.match(/^\s*\[([^\]]+)\]\s*(.*)$/);
+  if (!m?.[1]) return { rest: title, group: null };
+  const group = m[1].trim();
+  const rest = m[2] ?? "";
+  return { rest, group: group.length > 0 ? group : null };
+}
+function stripParens(s) {
+  return s.replace(/\([^)]*\)/g, " ");
+}
+function findReleaseInfoStart(s) {
+  const anchors = [
+    /\b(?:v|vol|volume)\.?\s*[0-9]+/i,
+    /\b[0-9]{3,4}\s*[-–]\s*[0-9]{3,4}\b/,
+    /\b(?:c|ch|chapter)\.?\s*[0-9]+/i
+  ];
+  let best = -1;
+  for (const re of anchors) {
+    const m = s.match(re);
+    if (m && m.index !== void 0 && (best === -1 || m.index < best)) {
+      best = m.index;
+    }
+  }
+  return best;
+}
+function tokenizeReleaseInfo(s) {
+  const tokens = [];
+  const tokenRe = new RegExp(
+    [
+      "\\b(?<vrs>v|vol|volume)\\.?\\s*([0-9]+)\\s*[-\u2013]\\s*([0-9]+)\\b",
+      "\\b(?<vss>v|vol|volume)\\.?\\s*([0-9]+)\\b",
+      "\\b(?<crs>c|ch|chapter)\\.?\\s*([0-9]+(?:\\.[0-9]+)?)\\s*[-\u2013]\\s*([0-9]+(?:\\.[0-9]+)?)\\b",
+      "\\b(?<css>c|ch|chapter)\\.?\\s*([0-9]+(?:\\.[0-9]+)?)\\b",
+      "\\b(?<brs>)([0-9]{3,4})\\s*[-\u2013]\\s*([0-9]{3,4})\\b",
+      "\\b(?<bss>)([0-9]{1,4})\\b"
+    ].join("|"),
+    "gi"
+  );
+  for (; ; ) {
+    const m = tokenRe.exec(s);
+    if (m === null) break;
+    const groups = m.groups ?? {};
+    if (groups.vrs !== void 0) {
+      const start = Number.parseInt(m[2] ?? "", 10);
+      const end = Number.parseInt(m[3] ?? "", 10);
+      if (Number.isFinite(start) && Number.isFinite(end)) {
+        tokens.push({ kind: "volRange", start, end });
+      }
+      continue;
+    }
+    if (groups.vss !== void 0) {
+      const value = Number.parseInt(m[5] ?? "", 10);
+      if (Number.isFinite(value)) tokens.push({ kind: "volume", value });
+      continue;
+    }
+    if (groups.crs !== void 0) {
+      const start = Number.parseFloat(m[7] ?? "");
+      const end = Number.parseFloat(m[8] ?? "");
+      if (Number.isFinite(start) && Number.isFinite(end)) {
+        tokens.push({ kind: "chapRange", start, end });
+      }
+      continue;
+    }
+    if (groups.css !== void 0) {
+      const value = Number.parseFloat(m[10] ?? "");
+      if (Number.isFinite(value)) tokens.push({ kind: "chapter", value });
+      continue;
+    }
+    if (groups.brs !== void 0) {
+      const start = Number.parseInt(m[12] ?? "", 10);
+      const end = Number.parseInt(m[13] ?? "", 10);
+      if (Number.isFinite(start) && Number.isFinite(end)) {
+        tokens.push({ kind: "chapRange", start, end });
+      }
+      continue;
+    }
+    if (groups.bss !== void 0) {
+      const raw = m[15] ?? "";
+      const value = Number.parseInt(raw, 10);
+      if (!Number.isFinite(value)) continue;
+      if (raw.length < 3 && tokens.length === 0) continue;
+      tokens.push({ kind: "chapter", value });
+    }
+  }
+  return tokens;
+}
+function aggregateTokens(tokens) {
+  let vMin = null;
+  let vMax = null;
+  let cMin = null;
+  let cMax = null;
+  for (const t of tokens) {
+    if (t.kind === "volume") {
+      vMin = vMin === null || t.value < vMin ? t.value : vMin;
+      vMax = vMax === null || t.value > vMax ? t.value : vMax;
+    } else if (t.kind === "volRange") {
+      vMin = vMin === null || t.start < vMin ? t.start : vMin;
+      vMax = vMax === null || t.end > vMax ? t.end : vMax;
+    } else if (t.kind === "chapter") {
+      cMin = cMin === null || t.value < cMin ? t.value : cMin;
+      cMax = cMax === null || t.value > cMax ? t.value : cMax;
+    } else {
+      cMin = cMin === null || t.start < cMin ? t.start : cMin;
+      cMax = cMax === null || t.end > cMax ? t.end : cMax;
+    }
+  }
+  return {
+    volume: vMin,
+    // Only emit a range-end when it actually differs from the start: a single
+    // volume is `volume=N, volumeRangeEnd=null`, matching the prior contract.
+    volumeRangeEnd: vMin !== null && vMax !== null && vMax !== vMin ? vMax : null,
+    chapter: cMin,
+    chapterRangeEnd: cMin !== null && cMax !== null && cMax !== cMin ? cMax : null
+  };
+}
+function extractFormatHints(s) {
+  const hints = {};
+  const tagRe = /\(([^)]+)\)/g;
+  for (; ; ) {
+    const match = tagRe.exec(s);
+    if (match === null) break;
+    const tag = (match[1] ?? "").trim().toLowerCase();
+    if (tag.length === 0) continue;
+    if (tag === "digital") hints.digital = true;
+    else if (tag === "jxl") hints.jxl = true;
+    else if (tag === "magazine" || tag === "mag-z") hints.magazine = true;
+    else if (tag === "webtoon") hints.webtoon = true;
+    else if (tag === "bw" || tag === "b&w") hints.bw = true;
+    else if (tag === "color") hints.color = true;
+    else if (tag === "omnibus" || tag === "omnibus edition") hints.omnibus = true;
+  }
+  return hints;
+}
+function stripTrailingBracket(s) {
+  return s.replace(/\s*\[[^\]]+\]\s*$/g, "").trim();
+}
+function extractSeriesAliases(nameRegion) {
+  const dashJoined = nameRegion.replace(/\s+[-–—]\s+/g, " ");
+  const parts = dashJoined.split(/\s+\/\s+/).map((p) => p.replace(/\s+/g, " ").trim()).filter((p) => p.length > 0);
+  if (parts.length === 0) return { primary: "", aliases: [] };
+  return { primary: parts[0] ?? "", aliases: parts };
+}
+function parseTitle(title) {
+  const trimmed = title.trim();
+  if (trimmed.length === 0) return null;
+  const { rest, group } = extractLeadingGroup(trimmed);
+  const formatHints = extractFormatHints(rest);
+  const flattened = stripTrailingBracket(stripParens(rest));
+  const anchor = findReleaseInfoStart(flattened);
+  const nameRegion = anchor === -1 ? flattened : flattened.slice(0, anchor);
+  const infoRegion = anchor === -1 ? "" : flattened.slice(anchor);
+  const tokens = tokenizeReleaseInfo(infoRegion);
+  const { volume, volumeRangeEnd, chapter, chapterRangeEnd } = aggregateTokens(tokens);
+  const { primary, aliases } = extractSeriesAliases(nameRegion);
+  return {
+    seriesGuess: primary,
+    seriesGuessAliases: aliases.length > 0 ? aliases : [primary],
+    chapter,
+    chapterRangeEnd,
+    volume,
+    volumeRangeEnd,
+    group,
+    formatHints
+  };
+}
+function pubDateToIso(raw) {
+  if (raw) {
+    const d = new Date(raw);
+    if (!Number.isNaN(d.getTime())) return d.toISOString();
+  }
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function derivePageUrl(guid) {
+  if (!guid) return null;
+  const trimmed = guid.trim();
+  if (trimmed.length === 0) return null;
+  if (/^https?:\/\/[^/]+\/view\/[^/?#]+/i.test(trimmed)) return trimmed;
+  return null;
+}
+function deriveExternalReleaseId(guid, link, infoHash, title, pubDate) {
+  if (guid && guid.trim().length > 0) return guid.trim();
+  if (link && link.trim().length > 0) return link.trim();
+  if (infoHash && infoHash.length > 0) return `urn:btih:${infoHash}`;
+  const fallback = `${title}|${pubDate ?? ""}`;
+  let h = 5381;
+  for (let i = 0; i < fallback.length; i++) {
+    h = (h << 5) + h + fallback.charCodeAt(i) | 0;
+  }
+  return `t:${(h >>> 0).toString(36)}`;
+}
+function parseItem(itemXml) {
+  const title = extractTagText(itemXml, "title");
+  if (!title) return null;
+  const link = extractTagText(itemXml, "link");
+  const guid = extractTagText(itemXml, "guid");
+  const pubDate = extractTagText(itemXml, "pubDate");
+  const infoHashRaw = extractTagText(itemXml, "nyaa:infoHash");
+  const infoHash = infoHashRaw ? infoHashRaw.toLowerCase().trim() : null;
+  const parsedTitle = parseTitle(title);
+  if (parsedTitle === null) return null;
+  return {
+    externalReleaseId: deriveExternalReleaseId(guid, link, infoHash, title, pubDate),
+    title,
+    seriesGuess: parsedTitle.seriesGuess,
+    seriesGuessAliases: parsedTitle.seriesGuessAliases,
+    chapter: parsedTitle.chapter,
+    chapterRangeEnd: parsedTitle.chapterRangeEnd,
+    volume: parsedTitle.volume,
+    volumeRangeEnd: parsedTitle.volumeRangeEnd,
+    group: parsedTitle.group,
+    formatHints: parsedTitle.formatHints,
+    link: link ?? "",
+    pageUrl: derivePageUrl(guid),
+    infoHash,
+    observedAt: pubDateToIso(pubDate)
+  };
+}
+function parseFeed(xml) {
+  return splitItems(xml).map(parseItem).filter((i) => i !== null);
+}
+
+// src/index.ts
+var logger = createLogger({ name: manifest.name, level: "info" });
+var state = {
+  hostRpc: null,
+  subscriptions: [],
+  requestTimeoutMs: DEFAULT_REQUEST_TIMEOUT_MS,
+  minConfidence: DEFAULT_MIN_CONFIDENCE,
+  baseUrl: null
+};
+function _resetState() {
+  state.hostRpc = null;
+  state.subscriptions = [];
+  state.requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS;
+  state.minConfidence = DEFAULT_MIN_CONFIDENCE;
+  state.baseUrl = null;
+}
+async function listTracked(rpc, sourceId, offset, limit) {
+  return rpc.call(RELEASES_METHODS.LIST_TRACKED, {
+    sourceId,
+    offset,
+    limit
+  });
+}
+async function recordCandidate(rpc, sourceId, candidate) {
+  try {
+    return await rpc.call(RELEASES_METHODS.RECORD, {
+      sourceId,
+      candidate
+    });
+  } catch (err) {
+    if (err instanceof HostRpcError) {
+      logger.warn(
+        `record failed for ${candidate.externalReleaseId}: ${err.message} (code ${err.code})`
+      );
+    } else {
+      const msg = err instanceof Error ? err.message : "unknown error";
+      logger.warn(`record failed for ${candidate.externalReleaseId}: ${msg}`);
+    }
+    return null;
+  }
+}
+async function fetchAllTracked(rpc, sourceId) {
+  const out = [];
+  const pageSize = 200;
+  let offset = 0;
+  while (true) {
+    const page = await listTracked(rpc, sourceId, offset, pageSize);
+    for (const entry of page.tracked) {
+      const aliases = entry.aliases ?? [];
+      if (aliases.length === 0) continue;
+      out.push({ seriesId: entry.seriesId, aliases });
+    }
+    if (page.nextOffset === void 0 || page.tracked.length === 0) return out;
+    offset = page.nextOffset;
+  }
+}
+function toCandidate(match, item, subscription) {
+  const formatHints = { ...item.formatHints };
+  if (item.chapterRangeEnd !== null) {
+    formatHints.chapterRangeEnd = item.chapterRangeEnd;
+  }
+  if (item.volumeRangeEnd !== null) {
+    formatHints.volumeRangeEnd = item.volumeRangeEnd;
+  }
+  formatHints.subscription = `${subscription.kind}:${subscription.identifier}`;
+  const torrentLink = item.link.length > 0 ? item.link : null;
+  const payloadUrl = item.pageUrl ?? torrentLink ?? `urn:nyaa:${item.externalReleaseId}`;
+  const hasDistinctMedia = item.pageUrl !== null && torrentLink !== null;
+  return {
+    seriesMatch: {
+      codexSeriesId: match.seriesId,
+      confidence: match.confidence,
+      reason: match.reason
+    },
+    externalReleaseId: item.externalReleaseId,
+    chapter: item.chapter,
+    volume: item.volume,
+    language: "en",
+    groupOrUploader: item.group ?? (subscription.kind === "user" ? subscription.identifier : null),
+    payloadUrl,
+    ...hasDistinctMedia ? { mediaUrl: torrentLink, mediaUrlKind: "torrent" } : {},
+    infoHash: item.infoHash,
+    formatHints,
+    observedAt: item.observedAt
+  };
+}
+async function pollSubscription(rpc, sourceId, subscription, candidates, options) {
+  const result = await fetchSubscriptionFeed(subscription, options.previousEtag, null, {
+    fetchImpl: options.fetchImpl,
+    timeoutMs: options.timeoutMs,
+    ...options.baseUrl ? { baseUrl: options.baseUrl } : {}
+  });
+  if (result.kind === "notModified") {
+    return {
+      subscription,
+      fetched: true,
+      notModified: true,
+      parsed: 0,
+      matched: 0,
+      recorded: 0,
+      deduped: 0,
+      upstreamStatus: 304,
+      etag: null,
+      error: ""
+    };
+  }
+  if (result.kind === "error") {
+    return {
+      subscription,
+      fetched: false,
+      notModified: false,
+      parsed: 0,
+      matched: 0,
+      recorded: 0,
+      deduped: 0,
+      upstreamStatus: result.status,
+      etag: null,
+      error: result.message
+    };
+  }
+  const items = parseFeed(result.body);
+  let matched = 0;
+  let recorded = 0;
+  let deduped = 0;
+  for (const item of items) {
+    const guesses = item.seriesGuessAliases.length > 0 ? item.seriesGuessAliases : [item.seriesGuess];
+    const m = matchSeriesAny(guesses, candidates, {
+      fuzzyFloor: options.minConfidence
+    });
+    if (m === null) continue;
+    matched++;
+    const candidate = toCandidate(m, item, subscription);
+    const outcome = await recordCandidate(rpc, sourceId, candidate);
+    if (!outcome) continue;
+    if (outcome.deduped) {
+      deduped++;
+    } else {
+      recorded++;
+    }
+  }
+  return {
+    subscription,
+    fetched: true,
+    notModified: false,
+    parsed: items.length,
+    matched,
+    recorded,
+    deduped,
+    upstreamStatus: 200,
+    etag: result.etag,
+    error: ""
+  };
+}
+function resolveSubscription(params) {
+  const cfg = params.config;
+  const fromConfig = cfg?.subscription;
+  if (fromConfig && typeof fromConfig === "object") {
+    const obj = fromConfig;
+    const kind = obj.kind;
+    const identifier = obj.identifier;
+    if (typeof identifier === "string" && identifier.length > 0 && (kind === "user" || kind === "query" || kind === "params")) {
+      return { kind, identifier };
+    }
+  }
+  if (typeof params.sourceKey === "string" && params.sourceKey.length > 0) {
+    return sourceKeyToSubscription(params.sourceKey);
+  }
+  return null;
+}
+async function poll(params, rpc) {
+  const sourceId = params.sourceId;
+  const subscription = resolveSubscription(params);
+  if (subscription === null) {
+    logger.warn(`source=${sourceId} no resolvable subscription on poll request; skipping`);
+    return { notModified: false, upstreamStatus: 200 };
+  }
+  const tracked = await fetchAllTracked(rpc, sourceId);
+  if (tracked.length === 0) {
+    logger.info(`no tracked series with aliases for source=${sourceId}`);
+    return { notModified: false, upstreamStatus: 200 };
+  }
+  const outcome = await pollSubscription(rpc, sourceId, subscription, tracked, {
+    previousEtag: params.etag ?? null,
+    timeoutMs: state.requestTimeoutMs,
+    minConfidence: state.minConfidence,
+    ...state.baseUrl ? { baseUrl: state.baseUrl } : {}
+  });
+  if (outcome.error) {
+    logger.warn(
+      `source=${sourceId} ${subscription.kind}:${subscription.identifier}: ${outcome.error} (status ${outcome.upstreamStatus})`
+    );
+  }
+  logger.info(
+    `poll complete: source=${sourceId} subscription=${subscription.kind}:${subscription.identifier} tracked=${tracked.length} parsed=${outcome.parsed} matched=${outcome.matched} recorded=${outcome.recorded} deduped=${outcome.deduped} status=${outcome.upstreamStatus}${outcome.notModified ? " (304)" : ""}`
+  );
+  return {
+    notModified: outcome.notModified,
+    upstreamStatus: outcome.upstreamStatus,
+    parsed: outcome.parsed,
+    matched: outcome.matched,
+    recorded: outcome.recorded,
+    deduped: outcome.deduped,
+    ...outcome.etag !== null ? { etag: outcome.etag } : {}
+  };
+}
+async function registerSources(rpc, subscriptions) {
+  const sources = subscriptions.map((sub) => ({
+    sourceKey: subscriptionToSourceKey(sub),
+    displayName: displayNameFor(sub),
+    kind: "rss-uploader",
+    config: { subscription: { kind: sub.kind, identifier: sub.identifier } }
+  }));
+  const maxAttempts = 5;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await rpc.call(
+        RELEASES_METHODS.REGISTER_SOURCES,
+        { sources }
+      );
+    } catch (err) {
+      const isMethodNotFound = err instanceof HostRpcError && err.code === -32601;
+      if (isMethodNotFound && attempt < maxAttempts) {
+        await new Promise((r) => setTimeout(r, 50 * attempt));
+        continue;
+      }
+      const reason = err instanceof Error ? err.message : String(err);
+      logger.error(`register_sources failed: ${reason}`);
+      return null;
+    }
+  }
+  return null;
+}
+function displayNameFor(sub) {
+  if (sub.kind === "user") return `Nyaa: ${sub.identifier}`;
+  if (sub.kind === "query") return `Nyaa search: ${sub.identifier}`;
+  return `Nyaa params: ${sub.identifier}`;
+}
+createReleaseSourcePlugin({
+  manifest,
+  provider: {
+    async poll(params) {
+      if (!state.hostRpc) {
+        throw new Error("Plugin not initialized: hostRpc client missing");
+      }
+      return poll(params, state.hostRpc);
+    }
+  },
+  logLevel: "info",
+  async onInitialize(params) {
+    state.hostRpc = params.hostRpc;
+    const ac = params.adminConfig ?? {};
+    state.subscriptions = parseSubscriptionList(ac.uploaders);
+    if (typeof ac.requestTimeoutMs === "number" && Number.isFinite(ac.requestTimeoutMs)) {
+      state.requestTimeoutMs = Math.max(1e3, Math.min(ac.requestTimeoutMs, 6e4));
+    }
+    if (typeof ac.baseUrl === "string" && ac.baseUrl.trim().length > 0) {
+      state.baseUrl = ac.baseUrl.trim();
+    }
+    logger.info(
+      `initialized: subscriptions=${state.subscriptions.length} timeoutMs=${state.requestTimeoutMs} minConfidence=${state.minConfidence}`
+    );
+    queueMicrotask(() => {
+      void registerSources(params.hostRpc, state.subscriptions).then((result) => {
+        if (result) {
+          logger.info(`register_sources: registered=${result.registered} pruned=${result.pruned}`);
+        }
+      });
+    });
+  }
+});
+logger.info("Nyaa release-source plugin started");
+export {
+  _resetState,
+  fetchAllTracked,
+  pollSubscription,
+  registerSources
+};
+//# sourceMappingURL=index.js.map