@character-foundry/character-foundry 0.1.3 → 0.1.6

package/dist/federation.js

@@ -1,2 +1,3893 @@
-export * from '@character-foundry/federation';
+// ../core/dist/index.js
+var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var LARGE_BUFFER_THRESHOLD = 1024 * 1024;
+var ENCODE_CHUNK_SIZE = 64 * 1024;
+var FOUNDRY_ERROR_MARKER = /* @__PURE__ */ Symbol.for("@character-foundry/core:FoundryError");
+var FoundryError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FoundryError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /** @internal Marker for cross-module identification */
+  [FOUNDRY_ERROR_MARKER] = true;
+};
+function formatUUID(bytes) {
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function mathRandomUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    return formatUUID(bytes);
+  }
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "development") {
+    console.warn("[character-foundry/core] generateUUID: Using insecure Math.random() fallback");
+  }
+  return mathRandomUUID();
+}
+
+// ../federation/dist/index.js
+var ACTIVITY_CONTEXT = [
+  "https://www.w3.org/ns/activitystreams",
+  {
+    "character": "https://character-foundry.dev/ns#",
+    "character:version": { "@id": "character:version" },
+    "character:spec": { "@id": "character:spec" }
+  }
+];
+var FORK_ACTIVITY_CONTEXT = [
+  "https://www.w3.org/ns/activitystreams",
+  {
+    "character": "https://character-foundry.dev/ns#",
+    "character:version": { "@id": "character:version" },
+    "character:spec": { "@id": "character:spec" },
+    "Fork": "character:Fork",
+    "forkedFrom": { "@id": "character:forkedFrom", "@type": "@id" }
+  }
+];
+var INSTALL_ACTIVITY_CONTEXT = [
+  "https://www.w3.org/ns/activitystreams",
+  {
+    "character": "https://character-foundry.dev/ns#",
+    "Install": "character:Install"
+  }
+];
+function generateCardId(baseUrl, localId) {
+  const encodedId = encodeURIComponent(localId);
+  return `${baseUrl}/cards/${encodedId}`;
+}
+function generateActivityId(baseUrl) {
+  const timestamp = Date.now();
+  const random = generateUUID().split("-")[0];
+  return `${baseUrl}/activities/${timestamp}-${random}`;
+}
+function cardToActivityPub(card, options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cardData = card.data;
+  const tags = cardData.tags?.map((tag) => ({
+    type: "Hashtag",
+    name: `#${tag.replace(/\s+/g, "_")}`
+  }));
+  const federatedCard = {
+    "@context": ACTIVITY_CONTEXT,
+    id: options.id,
+    type: "Note",
+    name: cardData.name,
+    summary: cardData.description?.substring(0, 500),
+    content: JSON.stringify(card),
+    mediaType: "application/json",
+    attributedTo: options.actorId,
+    published: options.published || now,
+    updated: options.updated,
+    tag: tags,
+    attachment: options.attachments,
+    "character:version": cardData.character_version,
+    "character:spec": card.spec_version
+  };
+  if (options.sourcePlatform && options.sourceId) {
+    federatedCard.source = {
+      platform: options.sourcePlatform,
+      id: options.sourceId,
+      url: options.sourceUrl
+    };
+  }
+  return federatedCard;
+}
+function cardFromActivityPub(federatedCard) {
+  try {
+    const card = JSON.parse(federatedCard.content);
+    if (card.spec !== "chara_card_v3") {
+      throw new Error("Invalid card spec");
+    }
+    return card;
+  } catch (err) {
+    throw new Error(
+      `Failed to parse card from ActivityPub: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function createCreateActivity(card, actorId, baseUrl, recipients) {
+  return {
+    "@context": ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Create",
+    actor: actorId,
+    object: card,
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: recipients?.to || ["https://www.w3.org/ns/activitystreams#Public"],
+    cc: recipients?.cc
+  };
+}
+function createUpdateActivity(card, actorId, baseUrl, recipients) {
+  return {
+    "@context": ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Update",
+    actor: actorId,
+    object: card,
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: recipients?.to || ["https://www.w3.org/ns/activitystreams#Public"],
+    cc: recipients?.cc
+  };
+}
+function createDeleteActivity(cardId, actorId, baseUrl, recipients) {
+  return {
+    "@context": ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Delete",
+    actor: actorId,
+    object: cardId,
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: recipients?.to || ["https://www.w3.org/ns/activitystreams#Public"],
+    cc: recipients?.cc
+  };
+}
+function createAnnounceActivity(cardId, actorId, baseUrl, recipients) {
+  return {
+    "@context": ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Announce",
+    actor: actorId,
+    object: cardId,
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: recipients?.to || ["https://www.w3.org/ns/activitystreams#Public"],
+    cc: recipients?.cc
+  };
+}
+function createLikeActivity(cardId, actorId, baseUrl) {
+  return {
+    "@context": ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Like",
+    actor: actorId,
+    object: cardId,
+    published: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createUndoActivity(originalActivityId, actorId, baseUrl) {
+  return {
+    "@context": ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Undo",
+    actor: actorId,
+    object: originalActivityId,
+    published: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createForkActivity(sourceCardId, forkedCard, actorId, baseUrl, recipients) {
+  return {
+    "@context": FORK_ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Fork",
+    actor: actorId,
+    object: sourceCardId,
+    result: forkedCard,
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: recipients?.to || ["https://www.w3.org/ns/activitystreams#Public"],
+    cc: recipients?.cc
+  };
+}
+function parseForkActivity(activity) {
+  if (!activity || typeof activity !== "object") {
+    return null;
+  }
+  const act = activity;
+  if (act.type !== "Fork") {
+    return null;
+  }
+  if (typeof act.actor !== "string" || typeof act.object !== "string" || typeof act.id !== "string" || !act.result || typeof act.result !== "object") {
+    return null;
+  }
+  const result = act.result;
+  if (typeof result.id !== "string" || typeof result.content !== "string" || typeof result.attributedTo !== "string") {
+    return null;
+  }
+  return {
+    sourceCardId: act.object,
+    forkedCard: result,
+    actor: act.actor,
+    activityId: act.id
+  };
+}
+function createInstallActivity(cardId, actorId, baseUrl, platform, recipients) {
+  return {
+    "@context": INSTALL_ACTIVITY_CONTEXT,
+    id: generateActivityId(baseUrl),
+    type: "Install",
+    actor: actorId,
+    object: cardId,
+    target: {
+      type: "Application",
+      name: platform
+    },
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: recipients?.to,
+    cc: recipients?.cc
+  };
+}
+function parseInstallActivity(activity) {
+  if (!activity || typeof activity !== "object") {
+    return null;
+  }
+  const act = activity;
+  if (act.type !== "Install") {
+    return null;
+  }
+  if (typeof act.actor !== "string" || typeof act.object !== "string" || typeof act.id !== "string") {
+    return null;
+  }
+  let platform = null;
+  if (act.target && typeof act.target === "object") {
+    const target = act.target;
+    if (target.type === "Application" && typeof target.name === "string") {
+      platform = target.name;
+    }
+  }
+  return {
+    cardId: act.object,
+    actor: act.actor,
+    platform,
+    activityId: act.id
+  };
+}
+function createActor(options) {
+  const actor = {
+    id: options.id,
+    type: "Person",
+    name: options.displayName,
+    preferredUsername: options.username,
+    summary: options.summary,
+    icon: options.icon,
+    inbox: `${options.id}/inbox`,
+    outbox: `${options.id}/outbox`,
+    followers: `${options.id}/followers`,
+    following: `${options.id}/following`
+  };
+  if (options.publicKeyPem) {
+    actor.publicKey = {
+      id: `${options.id}#main-key`,
+      owner: options.id,
+      publicKeyPem: options.publicKeyPem
+    };
+  }
+  return actor;
+}
+function parseActivity(data) {
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid activity: not an object");
+  }
+  const activity = data;
+  if (!activity.type || !activity.actor || !activity.object) {
+    throw new Error("Invalid activity: missing required fields");
+  }
+  return activity;
+}
+function hashCardFast(card) {
+  const content = JSON.stringify(card);
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+async function hashCardSecure(card) {
+  const content = JSON.stringify(card);
+  const data = new TextEncoder().encode(content);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var SyncEngine = class {
+  platforms = /* @__PURE__ */ new Map();
+  stateStore;
+  baseUrl;
+  actorId;
+  listeners = /* @__PURE__ */ new Map();
+  autoSyncTimer;
+  secureHashing;
+  /**
+   * Mutex flag to prevent concurrent syncAll() executions.
+   * When autoSyncInterval triggers while a sync is in progress,
+   * the new sync is skipped to prevent race conditions.
+   */
+  syncInProgress = false;
+  constructor(options) {
+    assertFederationEnabled("SyncEngine");
+    this.baseUrl = options.baseUrl;
+    this.actorId = options.actorId;
+    this.stateStore = options.stateStore;
+    this.secureHashing = options.secureHashing ?? false;
+    if (options.autoSyncInterval && options.autoSyncInterval > 0) {
+      this.autoSyncTimer = setInterval(
+        () => void this.syncAll(),
+        // void to handle Promise without blocking
+        options.autoSyncInterval
+      );
+    }
+  }
+  /**
+   * Generate a hash for change detection.
+   * Uses SHA-256 if secureHashing is enabled, otherwise fast 32-bit hash.
+   */
+  async hashCard(card) {
+    if (this.secureHashing) {
+      return hashCardSecure(card);
+    }
+    return hashCardFast(card);
+  }
+  /**
+   * Register a platform adapter
+   */
+  registerPlatform(adapter) {
+    this.platforms.set(adapter.platform, adapter);
+  }
+  /**
+   * Unregister a platform adapter
+   */
+  unregisterPlatform(platform) {
+    this.platforms.delete(platform);
+  }
+  /**
+   * Get registered platforms
+   */
+  getPlatforms() {
+    return Array.from(this.platforms.keys());
+  }
+  /**
+   * Add event listener
+   */
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(listener);
+  }
+  /**
+   * Remove event listener
+   */
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  /**
+   * Emit an event
+   */
+  emit(type, data) {
+    const event = {
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    };
+    const listeners = this.listeners.get(type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (err) {
+          console.error(`Event listener error:`, err);
+        }
+      }
+    }
+  }
+  /**
+   * Push a card from one platform to another
+   */
+  async pushCard(sourcePlatform, sourceId, targetPlatform) {
+    const operation = {
+      type: "push",
+      cardId: `${sourcePlatform}:${sourceId}`,
+      sourcePlatform,
+      targetPlatform,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const sourceAdapter = this.platforms.get(sourcePlatform);
+      if (!sourceAdapter) {
+        throw new Error(`Platform not registered: ${sourcePlatform}`);
+      }
+      const targetAdapter = this.platforms.get(targetPlatform);
+      if (!targetAdapter) {
+        throw new Error(`Platform not registered: ${targetPlatform}`);
+      }
+      if (!await sourceAdapter.isAvailable()) {
+        throw new Error(`Source platform unavailable: ${sourcePlatform}`);
+      }
+      if (!await targetAdapter.isAvailable()) {
+        throw new Error(`Target platform unavailable: ${targetPlatform}`);
+      }
+      const card = await sourceAdapter.getCard(sourceId);
+      if (!card) {
+        throw new Error(`Card not found: ${sourceId}`);
+      }
+      const federatedId = generateCardId(this.baseUrl, `${sourcePlatform}-${sourceId}`);
+      let syncState = await this.stateStore.get(federatedId);
+      if (syncState?.platformIds[targetPlatform]) {
+        const existingCard = await targetAdapter.getCard(syncState.platformIds[targetPlatform]);
+        if (existingCard) {
+          const existingHash = await this.hashCard(existingCard);
+          const newHash2 = await this.hashCard(card);
+          if (existingHash !== syncState.versionHash && newHash2 !== syncState.versionHash) {
+            syncState.status = "conflict";
+            syncState.conflict = {
+              localVersion: newHash2,
+              remoteVersion: existingHash,
+              remotePlatform: targetPlatform
+            };
+            await this.stateStore.set(syncState);
+            this.emit("card:conflict", { syncState, sourcePlatform, targetPlatform });
+            return {
+              success: false,
+              operation,
+              newState: syncState,
+              error: "Sync conflict detected"
+            };
+          }
+        }
+      }
+      const targetId = await targetAdapter.saveCard(
+        card,
+        syncState?.platformIds[targetPlatform]
+      );
+      const newHash = await this.hashCard(card);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const updatedState = syncState ?? {
+        localId: sourceId,
+        federatedId,
+        platformIds: {},
+        lastSync: {},
+        versionHash: newHash,
+        status: "synced"
+      };
+      updatedState.platformIds[sourcePlatform] = sourceId;
+      updatedState.platformIds[targetPlatform] = targetId;
+      updatedState.lastSync[sourcePlatform] = now;
+      updatedState.lastSync[targetPlatform] = now;
+      updatedState.versionHash = newHash;
+      updatedState.status = "synced";
+      updatedState.conflict = void 0;
+      await this.stateStore.set(updatedState);
+      this.emit("card:synced", { syncState: updatedState, sourcePlatform, targetPlatform });
+      return {
+        success: true,
+        operation,
+        newState: updatedState
+      };
+    } catch (err) {
+      this.emit("sync:failed", { operation, error: err });
+      return {
+        success: false,
+        operation,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Pull a card from a remote platform to local
+   */
+  async pullCard(remotePlatform, remoteId, localPlatform) {
+    return this.pushCard(remotePlatform, remoteId, localPlatform);
+  }
+  /**
+   * Sync a card across all registered platforms
+   */
+  async syncCardToAll(sourcePlatform, sourceId) {
+    const results = [];
+    for (const [platform] of this.platforms) {
+      if (platform === sourcePlatform) continue;
+      const result = await this.pushCard(sourcePlatform, sourceId, platform);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Sync all cards from one platform to another
+   */
+  async syncPlatform(sourcePlatform, targetPlatform) {
+    const sourceAdapter = this.platforms.get(sourcePlatform);
+    if (!sourceAdapter) {
+      throw new Error(`Platform not registered: ${sourcePlatform}`);
+    }
+    this.emit("sync:started", { sourcePlatform, targetPlatform });
+    const cards = await sourceAdapter.listCards();
+    const results = [];
+    for (const { id } of cards) {
+      const result = await this.pushCard(sourcePlatform, id, targetPlatform);
+      results.push(result);
+    }
+    this.emit("sync:completed", {
+      sourcePlatform,
+      targetPlatform,
+      total: results.length,
+      successful: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length
+    });
+    return results;
+  }
+  /**
+   * Sync all platforms with each other.
+   *
+   * Includes mutex protection to prevent concurrent executions when
+   * triggered by autoSyncInterval. If a sync is already in progress,
+   * subsequent calls are skipped and emit a 'sync:skipped' event.
+   */
+  async syncAll() {
+    if (this.syncInProgress) {
+      this.emit("sync:skipped", { reason: "already_in_progress", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      return /* @__PURE__ */ new Map();
+    }
+    this.syncInProgress = true;
+    try {
+      const results = /* @__PURE__ */ new Map();
+      const platforms = Array.from(this.platforms.keys());
+      for (let i = 0; i < platforms.length; i++) {
+        for (let j = i + 1; j < platforms.length; j++) {
+          const source = platforms[i];
+          const target = platforms[j];
+          const key = `${source}->${target}`;
+          results.set(key, await this.syncPlatform(source, target));
+        }
+      }
+      return results;
+    } finally {
+      this.syncInProgress = false;
+    }
+  }
+  /**
+   * Get sync state for a card
+   */
+  async getSyncState(federatedId) {
+    return this.stateStore.get(federatedId);
+  }
+  /**
+   * Find sync state by platform ID
+   */
+  async findSyncState(platform, platformId) {
+    return this.stateStore.findByPlatformId(platform, platformId);
+  }
+  /**
+   * Resolve a sync conflict by choosing a version
+   */
+  async resolveConflict(federatedId, resolution, mergedCard) {
+    const syncState = await this.stateStore.get(federatedId);
+    if (!syncState || syncState.status !== "conflict" || !syncState.conflict) {
+      throw new Error("No conflict to resolve");
+    }
+    const operation = {
+      type: "resolve",
+      cardId: federatedId,
+      sourcePlatform: "archive",
+      // Will be updated
+      targetPlatform: syncState.conflict.remotePlatform,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      let sourceCard = null;
+      let sourcePlatform = null;
+      if (resolution === "merge" && mergedCard) {
+        sourceCard = mergedCard;
+      } else if (resolution === "local") {
+        for (const [platform, id] of Object.entries(syncState.platformIds)) {
+          if (platform !== syncState.conflict.remotePlatform) {
+            const adapter = this.platforms.get(platform);
+            if (adapter) {
+              sourceCard = await adapter.getCard(id);
+              sourcePlatform = platform;
+              break;
+            }
+          }
+        }
+      } else if (resolution === "remote") {
+        const adapter = this.platforms.get(syncState.conflict.remotePlatform);
+        if (adapter) {
+          const remoteId = syncState.platformIds[syncState.conflict.remotePlatform];
+          if (remoteId) {
+            sourceCard = await adapter.getCard(remoteId);
+            sourcePlatform = syncState.conflict.remotePlatform;
+          }
+        }
+      }
+      if (!sourceCard) {
+        throw new Error("Could not resolve conflict: source card not found");
+      }
+      const newHash = await this.hashCard(sourceCard);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const [platform, id] of Object.entries(syncState.platformIds)) {
+        const adapter = this.platforms.get(platform);
+        if (adapter) {
+          await adapter.saveCard(sourceCard, id);
+          syncState.lastSync[platform] = now;
+        }
+      }
+      syncState.versionHash = newHash;
+      syncState.status = "synced";
+      syncState.conflict = void 0;
+      await this.stateStore.set(syncState);
+      this.emit("card:synced", { syncState, resolution });
+      return {
+        success: true,
+        operation,
+        newState: syncState
+      };
+    } catch (err) {
+      return {
+        success: false,
+        operation,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Fork a card from a remote source
+   *
+   * Creates a local copy of a remote card with fork metadata stored in
+   * the card's extensions and sync state. Optionally notifies the source
+   * instance about the fork.
+   *
+   * @param sourceFederatedId - Federated URI of the source card
+   * @param sourcePlatform - Platform where the source card resides
+   * @param targetPlatform - Platform to save the fork to
+   * @param options - Fork options
+   */
+  async forkCard(sourceFederatedId, sourcePlatform, targetPlatform, options) {
+    const operation = {
+      type: "fork",
+      cardId: sourceFederatedId,
+      sourcePlatform,
+      targetPlatform,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const sourceAdapter = this.platforms.get(sourcePlatform);
+      if (!sourceAdapter) {
+        throw new Error(`Platform not registered: ${sourcePlatform}`);
+      }
+      const targetAdapter = this.platforms.get(targetPlatform);
+      if (!targetAdapter) {
+        throw new Error(`Platform not registered: ${targetPlatform}`);
+      }
+      let sourceState = await this.stateStore.get(sourceFederatedId);
+      const sourceLocalId = sourceState?.platformIds[sourcePlatform];
+      if (!sourceLocalId) {
+        throw new Error(`Cannot find source card: ${sourceFederatedId}`);
+      }
+      const sourceCard = await sourceAdapter.getCard(sourceLocalId);
+      if (!sourceCard) {
+        throw new Error(`Source card not found: ${sourceLocalId}`);
+      }
+      const forkedCard = this.createForkedCard(
+        sourceCard,
+        sourceFederatedId,
+        sourcePlatform,
+        sourceState?.versionHash,
+        options?.modifications
+      );
+      const forkLocalId = await targetAdapter.saveCard(forkedCard);
+      const forkFederatedId = generateCardId(this.baseUrl, `${targetPlatform}-${forkLocalId}`);
+      const forkHash = await this.hashCard(forkedCard);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const forkReference = {
+        federatedId: sourceFederatedId,
+        platform: sourcePlatform,
+        forkedAt: now,
+        sourceVersionHash: sourceState?.versionHash
+      };
+      const forkState = {
+        localId: forkLocalId,
+        federatedId: forkFederatedId,
+        platformIds: { [targetPlatform]: forkLocalId },
+        lastSync: { [targetPlatform]: now },
+        versionHash: forkHash,
+        status: "synced",
+        forkedFrom: forkReference
+      };
+      await this.stateStore.set(forkState);
+      this.emit("card:forked", {
+        forkState,
+        sourceFederatedId,
+        sourcePlatform,
+        targetPlatform
+      });
+      return {
+        success: true,
+        operation,
+        forkState,
+        sourceFederatedId,
+        forkFederatedId
+      };
+    } catch (err) {
+      this.emit("sync:failed", { operation, error: err });
+      return {
+        success: false,
+        operation,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  /**
+   * Create a forked card with fork metadata in extensions
+   */
+  createForkedCard(source, sourceFederatedId, sourcePlatform, sourceVersionHash, modifications) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const forked = JSON.parse(JSON.stringify(source));
+    if (modifications) {
+      Object.assign(forked.data, modifications);
+    }
+    if (!forked.data.extensions) {
+      forked.data.extensions = {};
+    }
+    const cfExtension = forked.data.extensions["character-foundry"] || {};
+    cfExtension.forkedFrom = {
+      federatedId: sourceFederatedId,
+      platform: sourcePlatform,
+      forkedAt: now,
+      sourceVersionHash
+    };
+    forked.data.extensions["character-foundry"] = cfExtension;
+    forked.data.character_version = generateUUID();
+    return forked;
+  }
+  /**
+   * Handle incoming fork notification
+   *
+   * Called when another instance notifies us that they forked one of our cards.
+   * Increments the fork count and stores the notification.
+   */
+  async handleForkNotification(activity) {
+    const parsed = parseForkActivity(activity);
+    if (!parsed) {
+      throw new Error("Invalid fork activity");
+    }
+    const { sourceCardId, actor } = parsed;
+    const sourceState = await this.stateStore.get(sourceCardId);
+    if (!sourceState) {
+      return;
+    }
+    let forkPlatform = "custom";
+    if (actor.includes("archive")) forkPlatform = "archive";
+    else if (actor.includes("hub")) forkPlatform = "hub";
+    else if (actor.includes("editor")) forkPlatform = "editor";
+    else if (actor.includes("chub")) forkPlatform = "chub";
+    else if (actor.includes("risu")) forkPlatform = "risu";
+    const notification = {
+      forkId: parsed.forkedCard.id,
+      actorId: actor,
+      platform: forkPlatform,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const notifications = sourceState.forkNotifications || [];
+    if (notifications.length < 100) {
+      notifications.push(notification);
+    }
+    sourceState.forksCount = (sourceState.forksCount || 0) + 1;
+    sourceState.forkNotifications = notifications;
+    await this.stateStore.set(sourceState);
+    this.emit("card:fork-received", {
+      sourceCardId,
+      notification,
+      newForkCount: sourceState.forksCount
+    });
+  }
+  /**
+   * Handle incoming install notification
+   *
+   * Called when a consumer (SillyTavern, Voxta) notifies us that they installed one of our cards.
+   * Increments the install count and stores the notification.
+   */
+  async handleInstallNotification(activity) {
+    const parsed = parseInstallActivity(activity);
+    if (!parsed) {
+      throw new Error("Invalid install activity");
+    }
+    const { cardId, actor, platform } = parsed;
+    const cardState = await this.stateStore.get(cardId);
+    if (!cardState) {
+      return;
+    }
+    const installPlatform = platform || "custom";
+    if (!cardState.stats) {
+      cardState.stats = {
+        installCount: 0,
+        installsByPlatform: {},
+        forkCount: cardState.forksCount || 0,
+        likeCount: 0,
+        lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    cardState.stats.installCount++;
+    cardState.stats.installsByPlatform[installPlatform] = (cardState.stats.installsByPlatform[installPlatform] || 0) + 1;
+    cardState.stats.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    await this.stateStore.set(cardState);
+    this.emit("card:install-received", {
+      cardId,
+      platform: installPlatform,
+      actorId: actor,
+      newInstallCount: cardState.stats.installCount
+    });
+  }
+  /**
+   * Get stats for a card
+   */
+  async getCardStats(federatedId) {
+    const state = await this.stateStore.get(federatedId);
+    return state?.stats || null;
+  }
+  /**
+   * Get fork count for a card
+   */
+  async getForkCount(federatedId) {
+    const state = await this.stateStore.get(federatedId);
+    return state?.forksCount || 0;
+  }
+  /**
+   * Get install count for a card
+   */
+  async getInstallCount(federatedId) {
+    const state = await this.stateStore.get(federatedId);
+    return state?.stats?.installCount || 0;
+  }
+  /**
+   * Find all local forks of a source card
+   */
+  async findForks(sourceFederatedId) {
+    const allStates = await this.stateStore.list();
+    return allStates.filter(
+      (state) => state.forkedFrom?.federatedId === sourceFederatedId
+    );
+  }
+  /**
+   * Stop the sync engine
+   */
+  dispose() {
+    if (this.autoSyncTimer) {
+      clearInterval(this.autoSyncTimer);
+    }
+    this.listeners.clear();
+  }
+};
+var MemorySyncStateStore = class {
+  states = /* @__PURE__ */ new Map();
+  async get(federatedId) {
+    return this.states.get(federatedId) || null;
+  }
+  async set(state) {
+    this.states.set(state.federatedId, { ...state });
+  }
+  async delete(federatedId) {
+    this.states.delete(federatedId);
+  }
+  async list() {
+    return Array.from(this.states.values());
+  }
+  async findByPlatformId(platform, platformId) {
+    for (const state of this.states.values()) {
+      if (state.platformIds[platform] === platformId) {
+        return state;
+      }
+    }
+    return null;
+  }
+  /**
+   * Clear all states (for testing)
+   */
+  clear() {
+    this.states.clear();
+  }
+  /**
+   * Increment fork count and add notification
+   */
+  async incrementForkCount(federatedId, notification) {
+    const state = this.states.get(federatedId);
+    if (!state) return;
+    const notifications = state.forkNotifications || [];
+    if (notifications.length < 100) {
+      notifications.push(notification);
+    }
+    state.forksCount = (state.forksCount || 0) + 1;
+    state.forkNotifications = notifications;
+    this.states.set(federatedId, state);
+  }
+  /**
+   * Get fork count for a card
+   */
+  async getForkCount(federatedId) {
+    return this.states.get(federatedId)?.forksCount || 0;
+  }
+  /**
+   * Find all cards that are forks of a given source card
+   */
+  async findForks(sourceFederatedId) {
+    const forks = [];
+    for (const state of this.states.values()) {
+      if (state.forkedFrom?.federatedId === sourceFederatedId) {
+        forks.push(state);
+      }
+    }
+    return forks;
+  }
+};
+var FileSyncStateStore = class {
+  states = /* @__PURE__ */ new Map();
+  filePath;
+  saveDebounce;
+  fs;
+  constructor(filePath, fs) {
+    this.filePath = filePath;
+    this.fs = fs;
+  }
+  /**
+   * Load state from file
+   */
+  async load() {
+    try {
+      const content = await this.fs.readFile(this.filePath, "utf-8");
+      const data = JSON.parse(content);
+      this.states.clear();
+      for (const state of data) {
+        this.states.set(state.federatedId, state);
+      }
+    } catch (err) {
+      this.states.clear();
+    }
+  }
+  /**
+   * Save state to file (debounced)
+   */
+  scheduleSave() {
+    if (this.saveDebounce) {
+      clearTimeout(this.saveDebounce);
+    }
+    this.saveDebounce = setTimeout(() => this.saveNow(), 1e3);
+  }
+  /**
+   * Save state to file immediately
+   */
+  async saveNow() {
+    const data = Array.from(this.states.values());
+    const json = JSON.stringify(data, null, 2);
+    const dir = this.filePath.substring(0, this.filePath.lastIndexOf("/"));
+    if (dir) {
+      await this.fs.mkdir(dir, { recursive: true });
+    }
+    await this.fs.writeFile(this.filePath, json);
+  }
+  async get(federatedId) {
+    return this.states.get(federatedId) || null;
+  }
+  async set(state) {
+    this.states.set(state.federatedId, { ...state });
+    this.scheduleSave();
+  }
+  async delete(federatedId) {
+    this.states.delete(federatedId);
+    this.scheduleSave();
+  }
+  async list() {
+    return Array.from(this.states.values());
+  }
+  async findByPlatformId(platform, platformId) {
+    for (const state of this.states.values()) {
+      if (state.platformIds[platform] === platformId) {
+        return state;
+      }
+    }
+    return null;
+  }
+  /**
+   * Increment fork count and add notification
+   */
+  async incrementForkCount(federatedId, notification) {
+    const state = this.states.get(federatedId);
+    if (!state) return;
+    const notifications = state.forkNotifications || [];
+    if (notifications.length < 100) {
+      notifications.push(notification);
+    }
+    state.forksCount = (state.forksCount || 0) + 1;
+    state.forkNotifications = notifications;
+    this.states.set(federatedId, state);
+    this.scheduleSave();
+  }
+  /**
+   * Get fork count for a card
+   */
+  async getForkCount(federatedId) {
+    return this.states.get(federatedId)?.forksCount || 0;
+  }
+  /**
+   * Find all cards that are forks of a given source card
+   */
+  async findForks(sourceFederatedId) {
+    const forks = [];
+    for (const state of this.states.values()) {
+      if (state.forkedFrom?.federatedId === sourceFederatedId) {
+        forks.push(state);
+      }
+    }
+    return forks;
+  }
+};
+function createLocalStorageStore(key, storage) {
+  return {
+    async get(federatedId) {
+      const data = storage.getItem(`${key}:${federatedId}`);
+      return data ? JSON.parse(data) : null;
+    },
+    async set(state) {
+      storage.setItem(`${key}:${state.federatedId}`, JSON.stringify(state));
+      const indexKey = `${key}:__index__`;
+      const index = JSON.parse(storage.getItem(indexKey) || "[]");
+      if (!index.includes(state.federatedId)) {
+        index.push(state.federatedId);
+        storage.setItem(indexKey, JSON.stringify(index));
+      }
+    },
+    async delete(federatedId) {
+      storage.removeItem(`${key}:${federatedId}`);
+      const indexKey = `${key}:__index__`;
+      const index = JSON.parse(storage.getItem(indexKey) || "[]");
+      const newIndex = index.filter((id) => id !== federatedId);
+      storage.setItem(indexKey, JSON.stringify(newIndex));
+    },
+    async list() {
+      const indexKey = `${key}:__index__`;
+      const index = JSON.parse(storage.getItem(indexKey) || "[]");
+      const states = [];
+      for (const id of index) {
+        const data = storage.getItem(`${key}:${id}`);
+        if (data) {
+          states.push(JSON.parse(data));
+        }
+      }
+      return states;
+    },
+    async findByPlatformId(platform, platformId) {
+      const states = await this.list();
+      return states.find((s) => s.platformIds[platform] === platformId) || null;
+    }
+  };
+}
+function validateTableName(name) {
+  const validPattern = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  if (!validPattern.test(name)) {
+    throw new Error(
+      `Invalid table name "${name}": must start with a letter and contain only alphanumeric characters and underscores`
+    );
+  }
+  if (name.length > 64) {
+    throw new Error(`Invalid table name "${name}": must be 64 characters or less`);
+  }
+}
+var D1SyncStateStore = class {
+  db;
+  tableName;
+  /**
+   * Create a new D1SyncStateStore
+   *
+   * @param db - D1Database instance (from env.DB in Workers)
+   * @param tableName - Table name for storing sync state (default: 'federation_sync_state')
+   * @throws If tableName contains invalid characters (SQL injection prevention)
+   */
+  constructor(db, tableName = "federation_sync_state") {
+    validateTableName(tableName);
+    this.db = db;
+    this.tableName = tableName;
+  }
+  /**
+   * Initialize the database table
+   *
+   * Creates the sync state table if it doesn't exist.
+   * Safe to call multiple times (idempotent).
+   */
+  async init() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        federated_id TEXT PRIMARY KEY,
+        local_id TEXT NOT NULL,
+        platform_ids TEXT NOT NULL,
+        last_sync TEXT NOT NULL,
+        version_hash TEXT NOT NULL,
+        status TEXT NOT NULL CHECK (status IN ('synced', 'pending', 'conflict', 'error')),
+        conflict TEXT,
+        forked_from TEXT,
+        forks_count INTEGER DEFAULT 0,
+        fork_notifications TEXT,
+        stats TEXT,
+        created_at INTEGER DEFAULT (unixepoch()),
+        updated_at INTEGER DEFAULT (unixepoch())
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_local_id ON ${this.tableName}(local_id)
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.tableName}_forked_from
+      ON ${this.tableName}(json_extract(forked_from, '$.federatedId'))
+    `);
+  }
+  /**
+   * Get sync state for a federated card ID
+   */
+  async get(federatedId) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.tableName} WHERE federated_id = ?`).bind(federatedId).first();
+    return row ? this.rowToState(row) : null;
+  }
+  /**
+   * Save or update sync state
+   */
+  async set(state) {
+    const platformIds = JSON.stringify(state.platformIds);
+    const lastSync = JSON.stringify(state.lastSync);
+    const conflict = state.conflict ? JSON.stringify(state.conflict) : null;
+    const forkedFrom = state.forkedFrom ? JSON.stringify(state.forkedFrom) : null;
+    const forkNotifications = state.forkNotifications ? JSON.stringify(state.forkNotifications) : null;
+    const stats = state.stats ? JSON.stringify(state.stats) : null;
+    await this.db.prepare(
+      `INSERT INTO ${this.tableName} (federated_id, local_id, platform_ids, last_sync, version_hash, status, conflict, forked_from, forks_count, fork_notifications, stats, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, unixepoch())
+         ON CONFLICT(federated_id) DO UPDATE SET
+           local_id = excluded.local_id,
+           platform_ids = excluded.platform_ids,
+           last_sync = excluded.last_sync,
+           version_hash = excluded.version_hash,
+           status = excluded.status,
+           conflict = excluded.conflict,
+           forked_from = excluded.forked_from,
+           forks_count = excluded.forks_count,
+           fork_notifications = excluded.fork_notifications,
+           stats = excluded.stats,
+           updated_at = unixepoch()`
+    ).bind(
+      state.federatedId,
+      state.localId,
+      platformIds,
+      lastSync,
+      state.versionHash,
+      state.status,
+      conflict,
+      forkedFrom,
+      state.forksCount ?? 0,
+      forkNotifications,
+      stats
+    ).run();
+  }
+  /**
+   * Delete sync state for a federated card ID
+   */
+  async delete(federatedId) {
+    await this.db.prepare(`DELETE FROM ${this.tableName} WHERE federated_id = ?`).bind(federatedId).run();
+  }
+  /**
+   * List all sync states
+   */
+  async list() {
+    const result = await this.db.prepare(`SELECT * FROM ${this.tableName} ORDER BY updated_at DESC`).all();
+    return result.results.map((row) => this.rowToState(row));
+  }
+  /**
+   * Find sync state by platform-specific ID
+   *
+   * @param platform - Platform identifier
+   * @param platformId - Platform-specific card ID
+   * @returns Sync state if found, null otherwise
+   */
+  async findByPlatformId(platform, platformId) {
+    const result = await this.db.prepare(
+      `SELECT * FROM ${this.tableName}
+         WHERE json_extract(platform_ids, ?) = ?`
+    ).bind(`$.${platform}`, platformId).first();
+    return result ? this.rowToState(result) : null;
+  }
+  /**
+   * Find sync state by local ID
+   *
+   * @param localId - Local card ID
+   * @returns Sync state if found, null otherwise
+   */
+  async findByLocalId(localId) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.tableName} WHERE local_id = ?`).bind(localId).first();
+    return row ? this.rowToState(row) : null;
+  }
+  /**
+   * Get count of all sync states
+   */
+  async count() {
+    const result = await this.db.prepare(`SELECT COUNT(*) as count FROM ${this.tableName}`).first();
+    return result?.count ?? 0;
+  }
+  /**
+   * List sync states by status
+   *
+   * @param status - Status to filter by
+   * @returns Array of sync states with matching status
+   */
+  async listByStatus(status) {
+    const result = await this.db.prepare(
+      `SELECT * FROM ${this.tableName} WHERE status = ? ORDER BY updated_at DESC`
+    ).bind(status).all();
+    return result.results.map((row) => this.rowToState(row));
+  }
+  /**
+   * Clear all sync states (for testing)
+   *
+   * ⚠️  Use with caution - this deletes all data
+   */
+  async clear() {
+    await this.db.prepare(`DELETE FROM ${this.tableName}`).run();
+  }
+  /**
+   * Increment fork count and add notification for a source card
+   *
+   * Used when receiving a Fork activity to track that someone forked this card.
+   * Notifications are capped at 100 to prevent unbounded growth.
+   */
+  async incrementForkCount(federatedId, notification) {
+    const state = await this.get(federatedId);
+    if (!state) {
+      return;
+    }
+    const notifications = state.forkNotifications || [];
+    if (notifications.length < 100) {
+      notifications.push(notification);
+    }
+    state.forksCount = (state.forksCount || 0) + 1;
+    state.forkNotifications = notifications;
+    await this.set(state);
+  }
+  /**
+   * Get fork count for a card
+   */
+  async getForkCount(federatedId) {
+    const result = await this.db.prepare(`SELECT forks_count FROM ${this.tableName} WHERE federated_id = ?`).bind(federatedId).first();
+    return result?.forks_count ?? 0;
+  }
+  /**
+   * Find all cards that are forks of a given source card
+   */
+  async findForks(sourceFederatedId) {
+    const result = await this.db.prepare(
+      `SELECT * FROM ${this.tableName}
+         WHERE json_extract(forked_from, '$.federatedId') = ?
+         ORDER BY updated_at DESC`
+    ).bind(sourceFederatedId).all();
+    return result.results.map((row) => this.rowToState(row));
+  }
+  /**
+   * Convert database row to CardSyncState
+   */
+  rowToState(row) {
+    const state = {
+      federatedId: row.federated_id,
+      localId: row.local_id,
+      platformIds: JSON.parse(row.platform_ids),
+      lastSync: JSON.parse(row.last_sync),
+      versionHash: row.version_hash,
+      status: row.status,
+      conflict: row.conflict ? JSON.parse(row.conflict) : void 0
+    };
+    if (row.forked_from) {
+      state.forkedFrom = JSON.parse(row.forked_from);
+    }
+    if (row.forks_count > 0) {
+      state.forksCount = row.forks_count;
+    }
+    if (row.fork_notifications) {
+      state.forkNotifications = JSON.parse(row.fork_notifications);
+    }
+    if (row.stats) {
+      state.stats = JSON.parse(row.stats);
+    }
+    return state;
+  }
+};
+var BasePlatformAdapter = class {
+  /**
+   * Generate a new local ID using crypto-grade randomness
+   */
+  generateId() {
+    const timestamp = Date.now();
+    const random = generateUUID().split("-")[0];
+    return `${timestamp}-${random}`;
+  }
+};
+var MemoryPlatformAdapter = class extends BasePlatformAdapter {
+  platform;
+  displayName;
+  cards = /* @__PURE__ */ new Map();
+  assets = /* @__PURE__ */ new Map();
+  constructor(platform = "custom", displayName = "Memory Store") {
+    super();
+    this.platform = platform;
+    this.displayName = displayName;
+  }
+  async isAvailable() {
+    return true;
+  }
+  async getCard(localId) {
+    const entry = this.cards.get(localId);
+    return entry?.card || null;
+  }
+  async listCards(options) {
+    let cards = Array.from(this.cards.values());
+    if (options?.since) {
+      const sinceDate = new Date(options.since);
+      cards = cards.filter((c) => new Date(c.updatedAt) > sinceDate);
+    }
+    cards.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    const offset = options?.offset || 0;
+    const limit = options?.limit || cards.length;
+    cards = cards.slice(offset, offset + limit);
+    return cards;
+  }
+  async saveCard(card, localId) {
+    const id = localId || this.generateId();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.cards.get(id);
+    this.cards.set(id, {
+      id,
+      card,
+      updatedAt: now,
+      createdAt: existing?.createdAt || now
+    });
+    return id;
+  }
+  async deleteCard(localId) {
+    const existed = this.cards.has(localId);
+    this.cards.delete(localId);
+    this.assets.delete(localId);
+    return existed;
+  }
+  async getAssets(localId) {
+    return this.assets.get(localId) || [];
+  }
+  async getLastModified(localId) {
+    const entry = this.cards.get(localId);
+    return entry?.updatedAt || null;
+  }
+  /**
+   * Set assets for a card (for testing)
+   */
+  setAssets(localId, assets) {
+    this.assets.set(localId, assets);
+  }
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.cards.clear();
+    this.assets.clear();
+  }
+  /**
+   * Get card count
+   */
+  count() {
+    return this.cards.size;
+  }
+};
+var InvalidResourceIdError = class extends Error {
+  constructor(id, reason) {
+    super(`Invalid resource ID "${id}": ${reason}`);
+    this.id = id;
+    this.reason = reason;
+    this.name = "InvalidResourceIdError";
+  }
+};
+function validateAndEncodeId(id) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(id);
+  } catch {
+    throw new InvalidResourceIdError(id, "invalid URL encoding");
+  }
+  if (decoded.includes("..")) {
+    throw new InvalidResourceIdError(id, "path traversal detected");
+  }
+  if (decoded.startsWith("/")) {
+    throw new InvalidResourceIdError(id, "absolute path not allowed");
+  }
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(decoded)) {
+    throw new InvalidResourceIdError(id, "protocol injection detected");
+  }
+  if (decoded.includes("\\")) {
+    throw new InvalidResourceIdError(id, "backslash not allowed");
+  }
+  return encodeURIComponent(id);
+}
+var DEFAULT_TIMEOUT_MS = 3e4;
+var HttpPlatformAdapter = class extends BasePlatformAdapter {
+  platform;
+  displayName;
+  config;
+  fetchFn;
+  timeoutMs;
+  constructor(config) {
+    super();
+    this.platform = config.platform;
+    this.displayName = config.displayName;
+    this.config = config;
+    this.fetchFn = config.fetch || globalThis.fetch.bind(globalThis);
+    this.timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
+  }
+  /**
+   * Execute fetch with timeout using AbortController
+   *
+   * @security Prevents hanging connections that could cause resource exhaustion
+   */
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchFn(url, {
+        ...init,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Build headers for requests
+   */
+  buildHeaders(contentType) {
+    const headers = {};
+    if (contentType) {
+      headers["Content-Type"] = contentType;
+    }
+    if (this.config.auth) {
+      switch (this.config.auth.type) {
+        case "bearer":
+          headers["Authorization"] = `Bearer ${this.config.auth.token}`;
+          break;
+        case "api-key":
+          headers[this.config.auth.header || "X-API-Key"] = this.config.auth.token;
+          break;
+        case "basic":
+          headers["Authorization"] = `Basic ${this.config.auth.token}`;
+          break;
+      }
+    }
+    return headers;
+  }
+  /**
+   * Build full URL with optional resource ID.
+   *
+   * @security ID is validated and encoded to prevent SSRF/path traversal.
+   * @throws InvalidResourceIdError if ID contains malicious patterns
+   */
+  buildUrl(endpoint, id) {
+    let url = `${this.config.baseUrl}${endpoint}`;
+    if (id) {
+      const safeId = validateAndEncodeId(id);
+      url = `${url}/${safeId}`;
+    }
+    return url;
+  }
+  async isAvailable() {
+    try {
+      const endpoint = this.config.endpoints.health || this.config.endpoints.list;
+      const response = await this.fetchWithTimeout(
+        this.buildUrl(endpoint),
+        {
+          method: "GET",
+          headers: this.buildHeaders()
+        }
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getCard(localId) {
+    try {
+      const response = await this.fetchWithTimeout(
+        this.buildUrl(this.config.endpoints.get, localId),
+        {
+          method: "GET",
+          headers: this.buildHeaders()
+        }
+      );
+      if (!response.ok) {
+        if (response.status === 404) return null;
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.config.transformers?.get ? this.config.transformers.get(data) : data;
+    } catch (err) {
+      console.error(`Failed to get card ${localId}:`, err);
+      return null;
+    }
+  }
+  async listCards(options) {
+    const url = new URL(this.buildUrl(this.config.endpoints.list));
+    if (options?.limit) {
+      url.searchParams.set("limit", String(options.limit));
+    }
+    if (options?.offset) {
+      url.searchParams.set("offset", String(options.offset));
+    }
+    if (options?.since) {
+      url.searchParams.set("since", options.since);
+    }
+    const response = await this.fetchWithTimeout(
+      url.toString(),
+      {
+        method: "GET",
+        headers: this.buildHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return this.config.transformers?.list ? this.config.transformers.list(data) : data;
+  }
+  async saveCard(card, localId) {
+    if (localId) {
+      const body = this.config.transformers?.update ? this.config.transformers.update(card) : card;
+      const response = await this.fetchWithTimeout(
+        this.buildUrl(this.config.endpoints.update, localId),
+        {
+          method: "PUT",
+          headers: this.buildHeaders("application/json"),
+          body: JSON.stringify(body)
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return localId;
+    } else {
+      const body = this.config.transformers?.create ? this.config.transformers.create(card) : card;
+      const response = await this.fetchWithTimeout(
+        this.buildUrl(this.config.endpoints.create),
+        {
+          method: "POST",
+          headers: this.buildHeaders("application/json"),
+          body: JSON.stringify(body)
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const data = await response.json();
+      return this.config.transformers?.extractId ? this.config.transformers.extractId(data) : data.id;
+    }
+  }
+  async deleteCard(localId) {
+    const response = await this.fetchWithTimeout(
+      this.buildUrl(this.config.endpoints.delete, localId),
+      {
+        method: "DELETE",
+        headers: this.buildHeaders()
+      }
+    );
+    return response.ok;
+  }
+  async getAssets(localId) {
+    if (!this.config.endpoints.assets) {
+      return [];
+    }
+    try {
+      const response = await this.fetchWithTimeout(
+        this.buildUrl(this.config.endpoints.assets, localId),
+        {
+          method: "GET",
+          headers: this.buildHeaders()
+        }
+      );
+      if (!response.ok) {
+        return [];
+      }
+      return await response.json();
+    } catch {
+      return [];
+    }
+  }
+  async getLastModified(localId) {
+    try {
+      const response = await this.fetchWithTimeout(
+        this.buildUrl(this.config.endpoints.get, localId),
+        {
+          method: "HEAD",
+          headers: this.buildHeaders()
+        }
+      );
+      if (!response.ok) {
+        return null;
+      }
+      return response.headers.get("Last-Modified");
+    } catch {
+      return null;
+    }
+  }
+};
+function createArchiveAdapter(baseUrl, apiKey) {
+  return new HttpPlatformAdapter({
+    platform: "archive",
+    displayName: "Character Archive",
+    baseUrl,
+    endpoints: {
+      list: "/api/characters",
+      get: "/api/characters",
+      create: "/api/characters",
+      update: "/api/characters",
+      delete: "/api/characters",
+      assets: "/api/characters/assets",
+      health: "/api/health"
+    },
+    auth: apiKey ? { type: "api-key", token: apiKey } : void 0,
+    transformers: {
+      list: (data) => {
+        const response = data;
+        return response.characters.map((c) => ({
+          id: c.id,
+          card: c.data,
+          updatedAt: c.updatedAt
+        }));
+      },
+      get: (data) => data.data,
+      extractId: (data) => data.id
+    }
+  });
+}
+function createHubAdapter(baseUrl, apiKey) {
+  return new HttpPlatformAdapter({
+    platform: "hub",
+    displayName: "CardsHub",
+    baseUrl,
+    endpoints: {
+      list: "/api/cards",
+      get: "/api/cards",
+      create: "/api/cards",
+      update: "/api/cards",
+      delete: "/api/cards",
+      assets: "/api/cards/assets",
+      health: "/api/health"
+    },
+    auth: apiKey ? { type: "bearer", token: apiKey } : void 0
+  });
+}
+function stCharacterToCCv3(st) {
+  return {
+    spec: "chara_card_v3",
+    spec_version: "3.0",
+    data: {
+      name: st.data.name,
+      description: st.data.description,
+      personality: st.data.personality,
+      scenario: st.data.scenario,
+      first_mes: st.data.first_mes,
+      mes_example: st.data.mes_example,
+      creator_notes: st.data.creator_notes || "",
+      system_prompt: st.data.system_prompt || "",
+      post_history_instructions: st.data.post_history_instructions || "",
+      alternate_greetings: st.data.alternate_greetings || [],
+      group_only_greetings: [],
+      tags: st.data.tags || [],
+      creator: st.data.creator || "",
+      character_version: st.data.character_version || "",
+      character_book: st.data.character_book,
+      extensions: st.data.extensions || {}
+    }
+  };
+}
+function ccv3ToSTCharacter(card, filename) {
+  const data = card.data;
+  const name = filename || data.name.replace(/[^a-zA-Z0-9]/g, "_");
+  return {
+    name,
+    avatar: `${name}.png`,
+    data: {
+      name: data.name,
+      description: data.description,
+      personality: data.personality ?? "",
+      // Coerce null to empty string
+      scenario: data.scenario,
+      first_mes: data.first_mes,
+      mes_example: data.mes_example ?? "",
+      // Coerce null to empty string
+      creator_notes: data.creator_notes,
+      system_prompt: data.system_prompt,
+      post_history_instructions: data.post_history_instructions,
+      alternate_greetings: data.alternate_greetings,
+      // Cast character_book - ST format is compatible but types differ slightly
+      character_book: data.character_book,
+      tags: data.tags,
+      creator: data.creator,
+      character_version: data.character_version,
+      extensions: data.extensions
+    }
+  };
+}
+var SillyTavernAdapter = class extends BasePlatformAdapter {
+  platform = "sillytavern";
+  displayName = "SillyTavern";
+  bridge;
+  constructor(bridge) {
+    super();
+    this.bridge = bridge;
+  }
+  async isAvailable() {
+    return this.bridge.isConnected();
+  }
+  async getCard(localId) {
+    const st = await this.bridge.getCharacter(localId);
+    if (!st) return null;
+    return stCharacterToCCv3(st);
+  }
+  async listCards(options) {
+    const characters = await this.bridge.getCharacters();
+    let cards = characters.map((st) => ({
+      id: st.name,
+      card: stCharacterToCCv3(st),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      // ST doesn't track this
+    }));
+    const offset = options?.offset || 0;
+    const limit = options?.limit || cards.length;
+    cards = cards.slice(offset, offset + limit);
+    return cards;
+  }
+  async saveCard(card, localId) {
+    const stChar = ccv3ToSTCharacter(card, localId);
+    return this.bridge.saveCharacter(stChar);
+  }
+  async deleteCard(localId) {
+    return this.bridge.deleteCharacter(localId);
+  }
+  async getAssets(localId) {
+    const avatar = await this.bridge.getAvatar(localId);
+    if (!avatar) return [];
+    return [{
+      name: "avatar",
+      type: "icon",
+      data: avatar,
+      mimeType: "image/png"
+    }];
+  }
+  async getLastModified(localId) {
+    const char = await this.bridge.getCharacter(localId);
+    return char ? (/* @__PURE__ */ new Date()).toISOString() : null;
+  }
+  /**
+   * Get stats for a character (if bridge supports it)
+   */
+  async getStats(localId) {
+    if (!this.bridge.getCharacterStats) {
+      return null;
+    }
+    return this.bridge.getCharacterStats(localId);
+  }
+  /**
+   * Get stats for all characters (if bridge supports it)
+   */
+  async getAllStats() {
+    if (!this.bridge.getAllStats) {
+      return null;
+    }
+    return this.bridge.getAllStats();
+  }
+  /**
+   * Notify hub about installation (if bridge supports it)
+   */
+  async notifyInstall(federatedId, hubInbox) {
+    if (!this.bridge.notifyInstall) {
+      return false;
+    }
+    await this.bridge.notifyInstall(federatedId, hubInbox);
+    return true;
+  }
+};
+function createMockSTBridge() {
+  const characters = /* @__PURE__ */ new Map();
+  const avatars = /* @__PURE__ */ new Map();
+  const stats = /* @__PURE__ */ new Map();
+  const installNotifications = [];
+  return {
+    characters,
+    avatars,
+    stats,
+    installNotifications,
+    async getCharacters() {
+      return Array.from(characters.values());
+    },
+    async getCharacter(name) {
+      return characters.get(name) || null;
+    },
+    async saveCharacter(character) {
+      characters.set(character.name, character);
+      if (!stats.has(character.name)) {
+        stats.set(character.name, {
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          chatCount: 0,
+          messageCount: 0
+        });
+      }
+      return character.name;
+    },
+    async deleteCharacter(name) {
+      const existed = characters.has(name);
+      characters.delete(name);
+      avatars.delete(name);
+      stats.delete(name);
+      return existed;
+    },
+    async getAvatar(name) {
+      return avatars.get(name) || null;
+    },
+    async isConnected() {
+      return true;
+    },
+    async getCharacterStats(name) {
+      return stats.get(name) || null;
+    },
+    async getAllStats() {
+      return new Map(stats);
+    },
+    async notifyInstall(federatedId, hubInbox) {
+      installNotifications.push({ federatedId, hubInbox });
+    }
+  };
+}
+function handleWebFinger(resource, config) {
+  assertFederationEnabled("handleWebFinger");
+  if (!resource) return null;
+  const { actor } = config;
+  let domain;
+  try {
+    domain = new URL(actor.id).host;
+  } catch {
+    return null;
+  }
+  const validResources = [
+    `acct:${actor.preferredUsername}@${domain}`,
+    actor.id
+  ];
+  if (!validResources.includes(resource)) {
+    return null;
+  }
+  return {
+    subject: `acct:${actor.preferredUsername}@${domain}`,
+    aliases: [actor.id],
+    links: [
+      {
+        rel: "self",
+        type: "application/activity+json",
+        href: actor.id
+      },
+      {
+        rel: "http://webfinger.net/rel/profile-page",
+        type: "text/html",
+        href: actor.id
+        // Often the actor ID resolves to a profile page in browsers
+      }
+    ]
+  };
+}
+function handleNodeInfoDiscovery(baseUrl) {
+  assertFederationEnabled("handleNodeInfoDiscovery");
+  const origin = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return {
+    links: [
+      {
+        rel: "http://nodeinfo.diaspora.foundation/ns/schema/2.0",
+        href: `${origin}/api/federation/nodeinfo/2.0`
+      },
+      {
+        rel: "http://nodeinfo.diaspora.foundation/ns/schema/2.1",
+        href: `${origin}/api/federation/nodeinfo/2.1`
+      }
+    ]
+  };
+}
+function handleNodeInfo(config, version = "2.1") {
+  assertFederationEnabled("handleNodeInfo");
+  return {
+    version,
+    software: {
+      name: "character-foundry",
+      version: "0.1.0"
+    },
+    protocols: [
+      "activitypub"
+    ],
+    services: {
+      inbound: [],
+      outbound: []
+    },
+    openRegistrations: false,
+    usage: {
+      users: {
+        total: 1
+        // TODO: Count actual users if multi-tenant
+      }
+    },
+    metadata: {
+      nodeName: config.actor.name,
+      nodeDescription: config.actor.summary
+    }
+  };
+}
+function handleActor(config) {
+  assertFederationEnabled("handleActor");
+  return {
+    ...config.actor,
+    "@context": config.actor["@context"] || [
+      "https://www.w3.org/ns/activitystreams",
+      "https://w3id.org/security/v1"
+    ]
+  };
+}
+var MODERATION_ACTIVITY_CONTEXT = [
+  "https://www.w3.org/ns/activitystreams",
+  {
+    moderation: "https://character-foundry.dev/ns/moderation#",
+    category: { "@id": "moderation:category" }
+  }
+];
+function createFlagActivity(reporterActorId, targetIds, baseUrl, options) {
+  const targets = Array.isArray(targetIds) ? targetIds : [targetIds];
+  return {
+    "@context": [...MODERATION_ACTIVITY_CONTEXT],
+    id: generateActivityId(baseUrl),
+    type: "Flag",
+    actor: reporterActorId,
+    object: targets.length === 1 ? targets[0] : targets,
+    content: options?.content,
+    category: options?.category,
+    published: (/* @__PURE__ */ new Date()).toISOString(),
+    to: options?.to
+  };
+}
+function parseFlagActivity(activity) {
+  if (!activity || typeof activity !== "object") return null;
+  const act = activity;
+  if (act.type !== "Flag") return null;
+  if (typeof act.actor !== "string") return null;
+  if (typeof act.id !== "string") return null;
+  if (!act.object) return null;
+  const targets = Array.isArray(act.object) ? act.object.filter((t) => typeof t === "string") : typeof act.object === "string" ? [act.object] : [];
+  if (targets.length === 0) return null;
+  return {
+    actorId: act.actor,
+    targetIds: targets,
+    content: typeof act.content === "string" ? act.content : void 0,
+    category: typeof act.category === "string" ? act.category : void 0,
+    activityId: act.id
+  };
+}
+function validateFlagActivity(activity) {
+  const parsed = parseFlagActivity(activity);
+  if (!parsed) {
+    return {
+      valid: false,
+      error: "Invalid flag activity: missing required fields"
+    };
+  }
+  for (const target of parsed.targetIds) {
+    try {
+      new URL(target);
+    } catch {
+      return {
+        valid: false,
+        error: `Invalid flag activity: target "${target}" is not a valid URI`
+      };
+    }
+  }
+  if (parsed.content && parsed.content.length > 5e3) {
+    return {
+      valid: false,
+      error: "Flag content too long (max 5000 chars)"
+    };
+  }
+  return { valid: true };
+}
+function createBlockActivity(adminActorId, blockedTarget, baseUrl, options) {
+  return {
+    "@context": [...MODERATION_ACTIVITY_CONTEXT],
+    id: generateActivityId(baseUrl),
+    type: "Block",
+    actor: adminActorId,
+    object: blockedTarget,
+    summary: options?.summary,
+    published: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function parseBlockActivity(activity) {
+  if (!activity || typeof activity !== "object") return null;
+  const act = activity;
+  if (act.type !== "Block") return null;
+  if (typeof act.actor !== "string") return null;
+  if (typeof act.object !== "string") return null;
+  if (typeof act.id !== "string") return null;
+  return {
+    actorId: act.actor,
+    targetId: act.object,
+    summary: typeof act.summary === "string" ? act.summary : void 0,
+    activityId: act.id
+  };
+}
+function validateBlockActivity(activity) {
+  const parsed = parseBlockActivity(activity);
+  if (!parsed) {
+    return {
+      valid: false,
+      error: "Invalid block activity: missing required fields"
+    };
+  }
+  const target = parsed.targetId;
+  const isDomain = /^[a-zA-Z0-9][a-zA-Z0-9-]*(\.[a-zA-Z0-9][a-zA-Z0-9-]*)+$/.test(target);
+  let isValidUri = false;
+  try {
+    new URL(target);
+    isValidUri = true;
+  } catch {
+  }
+  if (!isDomain && !isValidUri) {
+    return {
+      valid: false,
+      error: "Invalid block activity: target must be a domain or valid URI"
+    };
+  }
+  return { valid: true };
+}
+var REQUIRED_SIGNED_HEADERS = ["(request-target)", "host", "date"];
+function parseSignatureHeader(header) {
+  const params = {};
+  const regex = /(\w+)="([^"]+)"/g;
+  let match;
+  while ((match = regex.exec(header)) !== null) {
+    params[match[1]] = match[2];
+  }
+  if (!params.keyId || !params.signature) {
+    return null;
+  }
+  return {
+    keyId: params.keyId,
+    algorithm: params.algorithm || "rsa-sha256",
+    headers: (params.headers || "(request-target) host date").split(" "),
+    signature: params.signature
+  };
+}
+function buildSigningString(method, path, headers, headerNames) {
+  const result = buildSigningStringStrict(method, path, headers, headerNames);
+  if (!result.success) {
+    console.warn(`[federation] Signature verification may fail: ${result.error}`);
+    const lines = [];
+    for (const name of headerNames) {
+      if (name === "(request-target)") {
+        lines.push(`(request-target): ${method.toLowerCase()} ${path}`);
+      } else if (name === "(created)" || name === "(expires)") {
+      } else {
+        const value = headers.get(name);
+        if (value !== null) {
+          lines.push(`${name.toLowerCase()}: ${value}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  return result.signingString;
+}
+function buildSigningStringStrict(method, path, headers, headerNames) {
+  const lines = [];
+  const missingHeaders = [];
+  const syntheticHeaders = /* @__PURE__ */ new Set(["(request-target)", "(created)", "(expires)"]);
+  for (const name of headerNames) {
+    if (name === "(request-target)") {
+      lines.push(`(request-target): ${method.toLowerCase()} ${path}`);
+    } else if (name === "(created)") {
+    } else if (name === "(expires)") {
+    } else {
+      const value = headers.get(name);
+      if (value !== null) {
+        lines.push(`${name.toLowerCase()}: ${value}`);
+      } else if (!syntheticHeaders.has(name)) {
+        missingHeaders.push(name);
+      }
+    }
+  }
+  if (missingHeaders.length > 0) {
+    return {
+      success: false,
+      error: `Signature claims to sign headers that are missing from request: ${missingHeaders.join(", ")}`,
+      missingHeaders
+    };
+  }
+  return {
+    success: true,
+    signingString: lines.join("\n")
+  };
+}
+async function verifyHttpSignature(parsed, publicKeyPem, method, path, headers, options = {}) {
+  try {
+    if (options.strictHeaders) {
+      const strictResult = buildSigningStringStrict(method, path, headers, parsed.headers);
+      if (!strictResult.success) {
+        console.warn(`[federation] Strict header verification failed: ${strictResult.error}`);
+        return false;
+      }
+    }
+    const signingString = buildSigningString(method, path, headers, parsed.headers);
+    const publicKey = await importPublicKey(publicKeyPem);
+    if (!publicKey) {
+      return false;
+    }
+    const signatureBytes = base64ToArrayBuffer(parsed.signature);
+    const encoder = new TextEncoder();
+    const data = encoder.encode(signingString);
+    const algorithm = parsed.algorithm === "hs2019" ? "RSASSA-PKCS1-v1_5" : "RSASSA-PKCS1-v1_5";
+    return await crypto.subtle.verify(
+      { name: algorithm, hash: "SHA-256" },
+      publicKey,
+      signatureBytes,
+      data
+    );
+  } catch (error) {
+    console.error("Signature verification failed:", error);
+    return false;
+  }
+}
+async function validateActivitySignature(activity, headers, options) {
+  const signatureHeader = headers.get("Signature");
+  if (!signatureHeader) {
+    return { valid: false, error: "Missing Signature header" };
+  }
+  const parsed = parseSignatureHeader(signatureHeader);
+  if (!parsed) {
+    return { valid: false, error: "Invalid Signature header format" };
+  }
+  if (options.strictMode) {
+    const missingHeaders = REQUIRED_SIGNED_HEADERS.filter(
+      (h) => !parsed.headers.includes(h)
+    );
+    if (missingHeaders.length > 0) {
+      return {
+        valid: false,
+        error: `Strict mode: signature missing required headers: ${missingHeaders.join(", ")}`
+      };
+    }
+    if (!headers.get("Date")) {
+      return { valid: false, error: "Strict mode: Date header required" };
+    }
+    if (!headers.get("host") && !headers.get("Host")) {
+      return { valid: false, error: "Strict mode: host header required" };
+    }
+  }
+  const dateHeader = headers.get("Date");
+  if (dateHeader) {
+    const requestDate = new Date(dateHeader);
+    const maxAge = options.maxAge ?? 300;
+    const now = Date.now();
+    const requestTime = requestDate.getTime();
+    if (isNaN(requestTime)) {
+      return { valid: false, error: "Invalid Date header" };
+    }
+    if (Math.abs(now - requestTime) > maxAge * 1e3) {
+      return { valid: false, error: "Request too old or in future" };
+    }
+  }
+  let keyIdBase;
+  let actorBase;
+  try {
+    const keyIdUrl = new URL(parsed.keyId);
+    const actorUrl = new URL(activity.actor);
+    keyIdBase = `${keyIdUrl.origin}${keyIdUrl.pathname}`;
+    actorBase = `${actorUrl.origin}${actorUrl.pathname}`;
+  } catch {
+    return { valid: false, error: "Invalid key ID or actor URL" };
+  }
+  if (keyIdBase !== actorBase) {
+    return { valid: false, error: "Key ID does not match activity actor" };
+  }
+  const actorId = keyIdBase;
+  const actor = await options.fetchActor(actorId);
+  if (!actor) {
+    return { valid: false, error: "Could not fetch actor" };
+  }
+  if (!actor.publicKey?.publicKeyPem) {
+    return { valid: false, error: "Actor has no public key" };
+  }
+  if (actor.publicKey.id !== parsed.keyId) {
+    return { valid: false, error: "Key ID mismatch" };
+  }
+  const valid = await verifyHttpSignature(
+    parsed,
+    actor.publicKey.publicKeyPem,
+    options.method,
+    options.path,
+    headers,
+    { strictHeaders: options.strictMode }
+  );
+  if (!valid) {
+    return { valid: false, error: "Invalid signature" };
+  }
+  return { valid: true, actor, keyId: parsed.keyId };
+}
+async function signRequest(options) {
+  if (!options.host) {
+    throw new Error("signRequest requires options.host - cannot generate valid signature without it");
+  }
+  const now = /* @__PURE__ */ new Date();
+  const dateString = now.toUTCString();
+  const headersToSign = ["(request-target)", "host", "date"];
+  const headerValues = new Headers();
+  headerValues.set("date", dateString);
+  headerValues.set("host", options.host);
+  if (options.digest) {
+    headersToSign.push("digest");
+    headerValues.set("digest", options.digest);
+  }
+  if (options.contentType) {
+    headersToSign.push("content-type");
+    headerValues.set("content-type", options.contentType);
+  }
+  const signingString = buildSigningString(
+    options.method,
+    options.path,
+    headerValues,
+    headersToSign
+  );
+  const privateKey = await importPrivateKey(options.privateKeyPem);
+  if (!privateKey) {
+    throw new Error("Failed to import private key");
+  }
+  const encoder = new TextEncoder();
+  const data = encoder.encode(signingString);
+  const signatureBuffer = await crypto.subtle.sign(
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    privateKey,
+    data
+  );
+  const signatureBase64 = arrayBufferToBase64(signatureBuffer);
+  const signatureHeader = `keyId="${options.keyId}",algorithm="rsa-sha256",headers="${headersToSign.join(" ")}",signature="${signatureBase64}"`;
+  return { signature: signatureHeader, date: dateString, host: options.host };
+}
+async function calculateDigest(body) {
+  const encoder = new TextEncoder();
+  const data = typeof body === "string" ? encoder.encode(body) : body;
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashBase64 = arrayBufferToBase64(hashBuffer);
+  return `SHA-256=${hashBase64}`;
+}
+async function importPublicKey(pem) {
+  try {
+    const pemContents = pem.replace(/-----BEGIN PUBLIC KEY-----/, "").replace(/-----END PUBLIC KEY-----/, "").replace(/-----BEGIN RSA PUBLIC KEY-----/, "").replace(/-----END RSA PUBLIC KEY-----/, "").replace(/\s/g, "");
+    const binaryDer = base64ToArrayBuffer(pemContents);
+    return await crypto.subtle.importKey(
+      "spki",
+      binaryDer,
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+  } catch (error) {
+    console.error("Failed to import public key:", error);
+    return null;
+  }
+}
+async function importPrivateKey(pem) {
+  try {
+    const pemContents = pem.replace(/-----BEGIN PRIVATE KEY-----/, "").replace(/-----END PRIVATE KEY-----/, "").replace(/-----BEGIN RSA PRIVATE KEY-----/, "").replace(/-----END RSA PRIVATE KEY-----/, "").replace(/\s/g, "");
+    const binaryDer = base64ToArrayBuffer(pemContents);
+    return await crypto.subtle.importKey(
+      "pkcs8",
+      binaryDer,
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+  } catch (error) {
+    console.error("Failed to import private key:", error);
+    return null;
+  }
+}
+function base64ToArrayBuffer(base64) {
+  const normalized = base64.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(normalized);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function arrayBufferToBase64(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function extractHostFromActorId(actorId) {
+  try {
+    const url = new URL(actorId);
+    return url.host;
+  } catch {
+    return null;
+  }
+}
+async function handleInbox(body, headers, options) {
+  assertFederationEnabled("handleInbox");
+  try {
+    if (options.moderationStore) {
+      const actorId = typeof body === "object" && body !== null && "actor" in body ? String(body.actor) : null;
+      if (actorId) {
+        const host = extractHostFromActorId(actorId);
+        if (host && await options.moderationStore.isInstanceBlocked(host)) {
+          return {
+            accepted: false,
+            error: `Instance ${host} is blocked`
+          };
+        }
+      }
+    }
+    let activity;
+    try {
+      activity = parseActivity(body);
+    } catch (err) {
+      return {
+        accepted: false,
+        error: `Invalid activity: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (options.strictMode) {
+      const signatureHeader = headers instanceof Headers ? headers.get("signature") : headers["signature"] || headers["Signature"];
+      if (!signatureHeader) {
+        return {
+          accepted: false,
+          error: "Missing Signature header (required in strict mode)"
+        };
+      }
+      const parsedSig = parseSignatureHeader(signatureHeader);
+      if (!parsedSig) {
+        return {
+          accepted: false,
+          error: "Invalid Signature header format"
+        };
+      }
+      const missingSignedHeaders = REQUIRED_SIGNED_HEADERS.filter(
+        (h) => !parsedSig.headers.includes(h)
+      );
+      if (missingSignedHeaders.length > 0) {
+        return {
+          accepted: false,
+          error: `Strict mode: signature missing required headers: ${missingSignedHeaders.join(", ")}`
+        };
+      }
+      const dateHeader = headers instanceof Headers ? headers.get("date") : headers["date"] || headers["Date"];
+      if (!dateHeader) {
+        return {
+          accepted: false,
+          error: "Strict mode: Date header required"
+        };
+      }
+      const hostHeader = headers instanceof Headers ? headers.get("host") : headers["host"] || headers["Host"];
+      if (!hostHeader) {
+        return {
+          accepted: false,
+          error: "Strict mode: host header required"
+        };
+      }
+      const actor = await options.fetchActor(activity.actor);
+      if (!actor) {
+        return {
+          accepted: false,
+          error: `Unknown actor: ${activity.actor}`
+        };
+      }
+      if (!actor.publicKey?.publicKeyPem) {
+        return {
+          accepted: false,
+          error: `Actor ${activity.actor} has no public key`
+        };
+      }
+      try {
+        const keyIdUrl = new URL(parsedSig.keyId);
+        const actorUrl = new URL(activity.actor);
+        const keyIdBase = `${keyIdUrl.origin}${keyIdUrl.pathname}`;
+        const actorBase = `${actorUrl.origin}${actorUrl.pathname}`;
+        if (keyIdBase !== actorBase) {
+          return {
+            accepted: false,
+            error: `Key ID ${parsedSig.keyId} does not match actor ${activity.actor}`
+          };
+        }
+        if (actor.publicKey.id !== parsedSig.keyId) {
+          return {
+            accepted: false,
+            error: `Actor's key ID ${actor.publicKey.id} does not match signature key ID ${parsedSig.keyId}`
+          };
+        }
+      } catch {
+        return {
+          accepted: false,
+          error: `Invalid key ID or actor URL`
+        };
+      }
+      const digestHeader = headers instanceof Headers ? headers.get("digest") : headers["digest"] || headers["Digest"];
+      if (digestHeader) {
+        if (!options.rawBody) {
+          return {
+            accepted: false,
+            error: "Digest header present but rawBody not provided for verification"
+          };
+        }
+        const digestMatch = digestHeader.match(/^(SHA-256|sha-256)=(.+)$/i);
+        if (!digestMatch) {
+          return {
+            accepted: false,
+            error: "Invalid Digest header format (expected SHA-256=...)"
+          };
+        }
+        const expectedDigest = await calculateDigest(options.rawBody);
+        const actualDigest = `SHA-256=${digestMatch[2]}`;
+        if (expectedDigest !== actualDigest) {
+          return {
+            accepted: false,
+            error: "Digest mismatch - body may have been tampered with"
+          };
+        }
+      } else if (parsedSig.headers.includes("digest")) {
+        return {
+          accepted: false,
+          error: "Signature includes digest but no Digest header present"
+        };
+      }
+      const method = options.method || "POST";
+      const path = options.path || "/inbox";
+      const normalizedHeaders = headers instanceof Headers ? headers : new Headers(headers);
+      const isValid = await verifyHttpSignature(
+        parsedSig,
+        actor.publicKey.publicKeyPem,
+        method,
+        path,
+        normalizedHeaders
+      );
+      if (!isValid) {
+        return {
+          accepted: false,
+          error: "Invalid HTTP signature"
+        };
+      }
+      const effectiveMaxAge = options.maxAge ?? 300;
+      const requestDate = new Date(dateHeader);
+      const now = /* @__PURE__ */ new Date();
+      const ageMs = Math.abs(now.getTime() - requestDate.getTime());
+      if (isNaN(requestDate.getTime())) {
+        return {
+          accepted: false,
+          error: "Invalid Date header format"
+        };
+      }
+      if (ageMs > effectiveMaxAge * 1e3) {
+        return {
+          accepted: false,
+          error: `Request too old or in future (${Math.round(ageMs / 1e3)}s, max ${effectiveMaxAge}s)`
+        };
+      }
+    }
+    const activityType = activity.type;
+    switch (activityType) {
+      case "Fork": {
+        if (options.onFork) {
+          const forkActivity = activity;
+          await options.onFork(forkActivity);
+        }
+        return { accepted: true, activityType: "Fork" };
+      }
+      case "Install": {
+        if (options.onInstall) {
+          const installActivity = activity;
+          await options.onInstall(installActivity);
+        }
+        return { accepted: true, activityType: "Install" };
+      }
+      case "Create": {
+        if (options.onCreate) {
+          await options.onCreate(activity);
+        }
+        return { accepted: true, activityType: "Create" };
+      }
+      case "Update": {
+        if (options.onUpdate) {
+          await options.onUpdate(activity);
+        }
+        return { accepted: true, activityType: "Update" };
+      }
+      case "Delete": {
+        if (options.onDelete) {
+          await options.onDelete(activity);
+        }
+        return { accepted: true, activityType: "Delete" };
+      }
+      case "Like": {
+        if (options.onLike) {
+          await options.onLike(activity);
+        }
+        return { accepted: true, activityType: "Like" };
+      }
+      case "Announce": {
+        if (options.onAnnounce) {
+          await options.onAnnounce(activity);
+        }
+        return { accepted: true, activityType: "Announce" };
+      }
+      case "Undo": {
+        if (options.onUndo) {
+          await options.onUndo(activity);
+        }
+        return { accepted: true, activityType: "Undo" };
+      }
+      case "Flag": {
+        const parsed = parseFlagActivity(activity);
+        if (options.onFlag && parsed) {
+          await options.onFlag(activity, parsed);
+        }
+        return { accepted: true, activityType: "Flag" };
+      }
+      case "Block": {
+        const parsed = parseBlockActivity(activity);
+        if (options.onBlock && parsed) {
+          await options.onBlock(activity, parsed);
+        }
+        return { accepted: true, activityType: "Block" };
+      }
+      default: {
+        return {
+          accepted: true,
+          activityType
+        };
+      }
+    }
+  } catch (err) {
+    return {
+      accepted: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function validateForkActivity(activity) {
+  const parsed = parseForkActivity(activity);
+  if (!parsed) {
+    return {
+      valid: false,
+      error: "Invalid fork activity: missing required fields"
+    };
+  }
+  try {
+    JSON.parse(parsed.forkedCard.content);
+  } catch {
+    return {
+      valid: false,
+      error: "Invalid fork activity: forked card content is not valid JSON"
+    };
+  }
+  return { valid: true };
+}
+function validateInstallActivity(activity) {
+  const parsed = parseInstallActivity(activity);
+  if (!parsed) {
+    return {
+      valid: false,
+      error: "Invalid install activity: missing required fields"
+    };
+  }
+  try {
+    new URL(parsed.cardId);
+  } catch {
+    return {
+      valid: false,
+      error: "Invalid install activity: cardId is not a valid URI"
+    };
+  }
+  return { valid: true };
+}
+var MemoryModerationStore = class {
+  reports = /* @__PURE__ */ new Map();
+  actions = /* @__PURE__ */ new Map();
+  blocks = /* @__PURE__ */ new Map();
+  policies = /* @__PURE__ */ new Map();
+  rateLimits = /* @__PURE__ */ new Map();
+  // ============ Report Operations ============
+  async createReport(report) {
+    const id = generateUUID();
+    const full = { ...report, id };
+    this.reports.set(id, full);
+    return full;
+  }
+  async getReport(id) {
+    return this.reports.get(id) || null;
+  }
+  async updateReport(id, updates) {
+    const existing = this.reports.get(id);
+    if (existing) {
+      this.reports.set(id, {
+        ...existing,
+        ...updates,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  async listReports(filters) {
+    let results = Array.from(this.reports.values());
+    if (filters?.status) {
+      results = results.filter((r) => r.status === filters.status);
+    }
+    if (filters?.category) {
+      results = results.filter((r) => r.category === filters.category);
+    }
+    if (filters?.targetId) {
+      results = results.filter((r) => r.targetIds.includes(filters.targetId));
+    }
+    if (filters?.reporterActorId) {
+      results = results.filter((r) => r.reporterActorId === filters.reporterActorId);
+    }
+    if (filters?.since) {
+      results = results.filter((r) => r.createdAt >= filters.since);
+    }
+    results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    const offset = filters?.offset || 0;
+    const limit = filters?.limit || 100;
+    return results.slice(offset, offset + limit);
+  }
+  async countReports(filters) {
+    let count = 0;
+    for (const report of this.reports.values()) {
+      if (!filters?.status || report.status === filters.status) {
+        count++;
+      }
+    }
+    return count;
+  }
+  // ============ Action Operations ============
+  async createAction(action) {
+    const id = generateUUID();
+    const full = { ...action, id };
+    this.actions.set(id, full);
+    return full;
+  }
+  async getAction(id) {
+    return this.actions.get(id) || null;
+  }
+  async listActions(filters) {
+    let results = Array.from(this.actions.values());
+    if (filters?.targetId) {
+      results = results.filter((a) => a.targetId === filters.targetId);
+    }
+    if (filters?.moderatorActorId) {
+      results = results.filter((a) => a.moderatorActorId === filters.moderatorActorId);
+    }
+    if (filters?.actionType) {
+      results = results.filter((a) => a.actionType === filters.actionType);
+    }
+    if (filters?.active !== void 0) {
+      results = results.filter((a) => a.active === filters.active);
+    }
+    if (filters?.since) {
+      results = results.filter((a) => a.timestamp >= filters.since);
+    }
+    results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return results.slice(0, filters?.limit || 100);
+  }
+  async deactivateAction(id) {
+    const action = this.actions.get(id);
+    if (action) {
+      this.actions.set(id, { ...action, active: false });
+    }
+  }
+  // ============ Instance Block Operations ============
+  async createBlock(block) {
+    const id = generateUUID();
+    const full = { ...block, id };
+    this.blocks.set(id, full);
+    return full;
+  }
+  async getBlock(id) {
+    return this.blocks.get(id) || null;
+  }
+  async getBlockByDomain(domain) {
+    const normalized = domain.toLowerCase();
+    for (const block of this.blocks.values()) {
+      if (block.blockedDomain.toLowerCase() === normalized && block.active) {
+        return block;
+      }
+    }
+    return null;
+  }
+  async listBlocks(filters) {
+    let results = Array.from(this.blocks.values());
+    if (filters?.active !== void 0) {
+      results = results.filter((b) => b.active === filters.active);
+    }
+    results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    return results;
+  }
+  async updateBlock(id, updates) {
+    const existing = this.blocks.get(id);
+    if (existing) {
+      this.blocks.set(id, { ...existing, ...updates });
+    }
+  }
+  async isInstanceBlocked(domain) {
+    const block = await this.getBlockByDomain(domain);
+    return block !== null;
+  }
+  // ============ Content Policy Operations ============
+  async createPolicy(policy) {
+    const id = generateUUID();
+    const full = { ...policy, id };
+    this.policies.set(id, full);
+    return full;
+  }
+  async getPolicy(id) {
+    return this.policies.get(id) || null;
+  }
+  async listPolicies(filters) {
+    let results = Array.from(this.policies.values());
+    if (filters?.enabled !== void 0) {
+      results = results.filter((p) => p.enabled === filters.enabled);
+    }
+    return results;
+  }
+  async updatePolicy(id, updates) {
+    const existing = this.policies.get(id);
+    if (existing) {
+      this.policies.set(id, {
+        ...existing,
+        ...updates,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  async deletePolicy(id) {
+    this.policies.delete(id);
+  }
+  // ============ Rate Limit Operations ============
+  async getRateLimitBucket(actorId) {
+    return this.rateLimits.get(actorId) || null;
+  }
+  async updateRateLimitBucket(bucket) {
+    this.rateLimits.set(bucket.actorId, bucket);
+  }
+  // ============ Audit ============
+  async getAuditLog(filters) {
+    let results = await this.listActions({
+      targetId: filters?.targetId,
+      moderatorActorId: filters?.actorId,
+      since: filters?.since,
+      limit: filters?.limit
+    });
+    if (filters?.until) {
+      results = results.filter((a) => a.timestamp <= filters.until);
+    }
+    return results;
+  }
+  // ============ Utility Methods ============
+  /**
+   * Clear all data (useful for testing)
+   */
+  clear() {
+    this.reports.clear();
+    this.actions.clear();
+    this.blocks.clear();
+    this.policies.clear();
+    this.rateLimits.clear();
+  }
+  /**
+   * Get counts for dashboard/stats
+   */
+  async getStats() {
+    const pendingReports = await this.countReports({ status: "pending" });
+    const activeActions = (await this.listActions({ active: true })).length;
+    const activeBlocks = (await this.listBlocks({ active: true })).length;
+    const enabledPolicies = (await this.listPolicies({ enabled: true })).length;
+    return {
+      reports: {
+        total: this.reports.size,
+        pending: pendingReports
+      },
+      actions: {
+        total: this.actions.size,
+        active: activeActions
+      },
+      blocks: {
+        total: this.blocks.size,
+        active: activeBlocks
+      },
+      policies: {
+        total: this.policies.size,
+        enabled: enabledPolicies
+      }
+    };
+  }
+};
+function validateTablePrefix(prefix) {
+  const validPattern = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  if (!validPattern.test(prefix)) {
+    throw new Error(
+      `Invalid table prefix "${prefix}": must start with a letter and contain only alphanumeric characters and underscores`
+    );
+  }
+  if (prefix.length > 32) {
+    throw new Error(`Invalid table prefix "${prefix}": must be 32 characters or less`);
+  }
+}
+var D1ModerationStore = class {
+  db;
+  prefix;
+  constructor(db, tablePrefix = "moderation") {
+    validateTablePrefix(tablePrefix);
+    this.db = db;
+    this.prefix = tablePrefix;
+  }
+  /**
+   * Initialize all moderation tables
+   */
+  async init() {
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_reports (
+        id TEXT PRIMARY KEY,
+        reporter_actor_id TEXT NOT NULL,
+        reporter_instance TEXT NOT NULL,
+        target_ids TEXT NOT NULL,
+        category TEXT NOT NULL,
+        description TEXT NOT NULL,
+        status TEXT NOT NULL,
+        activity_id TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        receiving_instance TEXT NOT NULL,
+        federated_to_target INTEGER NOT NULL DEFAULT 0,
+        metadata TEXT
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.prefix}_reports_status
+      ON ${this.prefix}_reports(status)
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.prefix}_reports_reporter
+      ON ${this.prefix}_reports(reporter_actor_id)
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_actions (
+        id TEXT PRIMARY KEY,
+        report_id TEXT,
+        moderator_actor_id TEXT NOT NULL,
+        target_id TEXT NOT NULL,
+        action_type TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        expires_at TEXT,
+        active INTEGER NOT NULL DEFAULT 1,
+        reverses_action_id TEXT,
+        approved_by TEXT,
+        metadata TEXT
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.prefix}_actions_target
+      ON ${this.prefix}_actions(target_id)
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.prefix}_actions_active
+      ON ${this.prefix}_actions(active)
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_blocks (
+        id TEXT PRIMARY KEY,
+        blocked_domain TEXT NOT NULL UNIQUE,
+        level TEXT NOT NULL CHECK (level IN ('suspend', 'silence', 'reject_media')),
+        reason TEXT NOT NULL,
+        created_by TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        active INTEGER NOT NULL DEFAULT 1,
+        public_comment TEXT,
+        federate INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    await this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_${this.prefix}_blocks_domain
+      ON ${this.prefix}_blocks(blocked_domain)
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_policies (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT NOT NULL,
+        rules TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        default_action TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+    await this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.prefix}_rate_limits (
+        actor_id TEXT PRIMARY KEY,
+        tokens REAL NOT NULL,
+        max_tokens INTEGER NOT NULL,
+        last_refill TEXT NOT NULL,
+        refill_rate REAL NOT NULL
+      )
+    `);
+  }
+  // ============ Report Operations ============
+  async createReport(report) {
+    const id = crypto.randomUUID();
+    const full = { ...report, id };
+    await this.db.prepare(
+      `INSERT INTO ${this.prefix}_reports
+         (id, reporter_actor_id, reporter_instance, target_ids, category, description, status,
+          activity_id, created_at, updated_at, receiving_instance, federated_to_target, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).bind(
+      id,
+      report.reporterActorId,
+      report.reporterInstance,
+      JSON.stringify(report.targetIds),
+      report.category,
+      report.description,
+      report.status,
+      report.activityId,
+      report.createdAt,
+      report.updatedAt,
+      report.receivingInstance,
+      report.federatedToTarget ? 1 : 0,
+      report.metadata ? JSON.stringify(report.metadata) : null
+    ).run();
+    return full;
+  }
+  async getReport(id) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.prefix}_reports WHERE id = ?`).bind(id).first();
+    return row ? this.rowToReport(row) : null;
+  }
+  async updateReport(id, updates) {
+    const existing = await this.getReport(id);
+    if (!existing) return;
+    const merged = { ...existing, ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.db.prepare(
+      `UPDATE ${this.prefix}_reports SET
+         reporter_actor_id = ?, reporter_instance = ?, target_ids = ?, category = ?,
+         description = ?, status = ?, activity_id = ?, updated_at = ?,
+         receiving_instance = ?, federated_to_target = ?, metadata = ?
+         WHERE id = ?`
+    ).bind(
+      merged.reporterActorId,
+      merged.reporterInstance,
+      JSON.stringify(merged.targetIds),
+      merged.category,
+      merged.description,
+      merged.status,
+      merged.activityId,
+      merged.updatedAt,
+      merged.receivingInstance,
+      merged.federatedToTarget ? 1 : 0,
+      merged.metadata ? JSON.stringify(merged.metadata) : null,
+      id
+    ).run();
+  }
+  async listReports(filters) {
+    const conditions = ["1=1"];
+    const bindings = [];
+    if (filters?.status) {
+      conditions.push("status = ?");
+      bindings.push(filters.status);
+    }
+    if (filters?.category) {
+      conditions.push("category = ?");
+      bindings.push(filters.category);
+    }
+    if (filters?.targetId) {
+      conditions.push("target_ids LIKE ?");
+      bindings.push(`%${filters.targetId}%`);
+    }
+    if (filters?.reporterActorId) {
+      conditions.push("reporter_actor_id = ?");
+      bindings.push(filters.reporterActorId);
+    }
+    if (filters?.since) {
+      conditions.push("created_at >= ?");
+      bindings.push(filters.since);
+    }
+    const limit = filters?.limit ?? 100;
+    const offset = filters?.offset ?? 0;
+    let stmt = this.db.prepare(
+      `SELECT * FROM ${this.prefix}_reports
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY created_at DESC
+       LIMIT ? OFFSET ?`
+    );
+    for (const binding of bindings) {
+      stmt = stmt.bind(binding);
+    }
+    stmt = stmt.bind(limit, offset);
+    const result = await stmt.all();
+    return result.results.map((row) => this.rowToReport(row));
+  }
+  async countReports(filters) {
+    let query = `SELECT COUNT(*) as count FROM ${this.prefix}_reports`;
+    const bindings = [];
+    if (filters?.status) {
+      query += " WHERE status = ?";
+      bindings.push(filters.status);
+    }
+    let stmt = this.db.prepare(query);
+    for (const binding of bindings) {
+      stmt = stmt.bind(binding);
+    }
+    const result = await stmt.first();
+    return result?.count ?? 0;
+  }
+  // ============ Action Operations ============
+  async createAction(action) {
+    const id = crypto.randomUUID();
+    const full = { ...action, id };
+    await this.db.prepare(
+      `INSERT INTO ${this.prefix}_actions
+         (id, report_id, moderator_actor_id, target_id, action_type, reason, timestamp,
+          expires_at, active, reverses_action_id, approved_by, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).bind(
+      id,
+      action.reportId ?? null,
+      action.moderatorActorId,
+      action.targetId,
+      action.actionType,
+      action.reason,
+      action.timestamp,
+      action.expiresAt ?? null,
+      action.active ? 1 : 0,
+      action.reversesActionId ?? null,
+      action.approvedBy ? JSON.stringify(action.approvedBy) : null,
+      action.metadata ? JSON.stringify(action.metadata) : null
+    ).run();
+    return full;
+  }
+  async getAction(id) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.prefix}_actions WHERE id = ?`).bind(id).first();
+    return row ? this.rowToAction(row) : null;
+  }
+  async listActions(filters) {
+    const conditions = ["1=1"];
+    const bindings = [];
+    if (filters?.targetId) {
+      conditions.push("target_id = ?");
+      bindings.push(filters.targetId);
+    }
+    if (filters?.moderatorActorId) {
+      conditions.push("moderator_actor_id = ?");
+      bindings.push(filters.moderatorActorId);
+    }
+    if (filters?.actionType) {
+      conditions.push("action_type = ?");
+      bindings.push(filters.actionType);
+    }
+    if (filters?.active !== void 0) {
+      conditions.push("active = ?");
+      bindings.push(filters.active ? 1 : 0);
+    }
+    if (filters?.since) {
+      conditions.push("timestamp >= ?");
+      bindings.push(filters.since);
+    }
+    const limit = filters?.limit ?? 100;
+    let stmt = this.db.prepare(
+      `SELECT * FROM ${this.prefix}_actions
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY timestamp DESC
+       LIMIT ?`
+    );
+    for (const binding of bindings) {
+      stmt = stmt.bind(binding);
+    }
+    stmt = stmt.bind(limit);
+    const result = await stmt.all();
+    return result.results.map((row) => this.rowToAction(row));
+  }
+  async deactivateAction(id) {
+    await this.db.prepare(`UPDATE ${this.prefix}_actions SET active = 0 WHERE id = ?`).bind(id).run();
+  }
+  // ============ Instance Block Operations ============
+  async createBlock(block) {
+    const id = crypto.randomUUID();
+    const full = { ...block, id };
+    await this.db.prepare(
+      `INSERT INTO ${this.prefix}_blocks
+         (id, blocked_domain, level, reason, created_by, created_at, active, public_comment, federate)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).bind(
+      id,
+      block.blockedDomain.toLowerCase(),
+      block.level,
+      block.reason,
+      block.createdBy,
+      block.createdAt,
+      block.active ? 1 : 0,
+      block.publicComment ?? null,
+      block.federate ? 1 : 0
+    ).run();
+    return full;
+  }
+  async getBlock(id) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.prefix}_blocks WHERE id = ?`).bind(id).first();
+    return row ? this.rowToBlock(row) : null;
+  }
+  async getBlockByDomain(domain) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.prefix}_blocks WHERE blocked_domain = ? AND active = 1`).bind(domain.toLowerCase()).first();
+    return row ? this.rowToBlock(row) : null;
+  }
+  async listBlocks(filters) {
+    let query = `SELECT * FROM ${this.prefix}_blocks`;
+    const bindings = [];
+    if (filters?.active !== void 0) {
+      query += " WHERE active = ?";
+      bindings.push(filters.active ? 1 : 0);
+    }
+    query += " ORDER BY created_at DESC";
+    let stmt = this.db.prepare(query);
+    for (const binding of bindings) {
+      stmt = stmt.bind(binding);
+    }
+    const result = await stmt.all();
+    return result.results.map((row) => this.rowToBlock(row));
+  }
+  async updateBlock(id, updates) {
+    const existing = await this.getBlock(id);
+    if (!existing) return;
+    const merged = { ...existing, ...updates };
+    await this.db.prepare(
+      `UPDATE ${this.prefix}_blocks SET
+         blocked_domain = ?, level = ?, reason = ?, active = ?, public_comment = ?, federate = ?
+         WHERE id = ?`
+    ).bind(
+      merged.blockedDomain.toLowerCase(),
+      merged.level,
+      merged.reason,
+      merged.active ? 1 : 0,
+      merged.publicComment ?? null,
+      merged.federate ? 1 : 0,
+      id
+    ).run();
+  }
+  async isInstanceBlocked(domain) {
+    const block = await this.getBlockByDomain(domain);
+    return block !== null;
+  }
+  // ============ Content Policy Operations ============
+  async createPolicy(policy) {
+    const id = crypto.randomUUID();
+    const full = { ...policy, id };
+    await this.db.prepare(
+      `INSERT INTO ${this.prefix}_policies
+         (id, name, description, rules, enabled, default_action, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+    ).bind(
+      id,
+      policy.name,
+      policy.description,
+      JSON.stringify(policy.rules),
+      policy.enabled ? 1 : 0,
+      policy.defaultAction,
+      policy.updatedAt
+    ).run();
+    return full;
+  }
+  async getPolicy(id) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.prefix}_policies WHERE id = ?`).bind(id).first();
+    return row ? this.rowToPolicy(row) : null;
+  }
+  async listPolicies(filters) {
+    let query = `SELECT * FROM ${this.prefix}_policies`;
+    const bindings = [];
+    if (filters?.enabled !== void 0) {
+      query += " WHERE enabled = ?";
+      bindings.push(filters.enabled ? 1 : 0);
+    }
+    query += " ORDER BY name ASC";
+    let stmt = this.db.prepare(query);
+    for (const binding of bindings) {
+      stmt = stmt.bind(binding);
+    }
+    const result = await stmt.all();
+    return result.results.map((row) => this.rowToPolicy(row));
+  }
+  async updatePolicy(id, updates) {
+    const existing = await this.getPolicy(id);
+    if (!existing) return;
+    const merged = { ...existing, ...updates, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.db.prepare(
+      `UPDATE ${this.prefix}_policies SET
+         name = ?, description = ?, rules = ?, enabled = ?, default_action = ?, updated_at = ?
+         WHERE id = ?`
+    ).bind(
+      merged.name,
+      merged.description,
+      JSON.stringify(merged.rules),
+      merged.enabled ? 1 : 0,
+      merged.defaultAction,
+      merged.updatedAt,
+      id
+    ).run();
+  }
+  async deletePolicy(id) {
+    await this.db.prepare(`DELETE FROM ${this.prefix}_policies WHERE id = ?`).bind(id).run();
+  }
+  // ============ Rate Limit Operations ============
+  async getRateLimitBucket(actorId) {
+    const row = await this.db.prepare(`SELECT * FROM ${this.prefix}_rate_limits WHERE actor_id = ?`).bind(actorId).first();
+    return row ? this.rowToRateLimit(row) : null;
+  }
+  async updateRateLimitBucket(bucket) {
+    await this.db.prepare(
+      `INSERT INTO ${this.prefix}_rate_limits (actor_id, tokens, max_tokens, last_refill, refill_rate)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(actor_id) DO UPDATE SET
+           tokens = excluded.tokens,
+           max_tokens = excluded.max_tokens,
+           last_refill = excluded.last_refill,
+           refill_rate = excluded.refill_rate`
+    ).bind(bucket.actorId, bucket.tokens, bucket.maxTokens, bucket.lastRefill, bucket.refillRate).run();
+  }
+  // ============ Audit ============
+  async getAuditLog(filters) {
+    const conditions = ["1=1"];
+    const bindings = [];
+    if (filters?.targetId) {
+      conditions.push("target_id = ?");
+      bindings.push(filters.targetId);
+    }
+    if (filters?.actorId) {
+      conditions.push("moderator_actor_id = ?");
+      bindings.push(filters.actorId);
+    }
+    if (filters?.since) {
+      conditions.push("timestamp >= ?");
+      bindings.push(filters.since);
+    }
+    if (filters?.until) {
+      conditions.push("timestamp <= ?");
+      bindings.push(filters.until);
+    }
+    const limit = filters?.limit ?? 100;
+    let stmt = this.db.prepare(
+      `SELECT * FROM ${this.prefix}_actions
+       WHERE ${conditions.join(" AND ")}
+       ORDER BY timestamp DESC
+       LIMIT ?`
+    );
+    for (const binding of bindings) {
+      stmt = stmt.bind(binding);
+    }
+    stmt = stmt.bind(limit);
+    const result = await stmt.all();
+    return result.results.map((row) => this.rowToAction(row));
+  }
+  // ============ Utility Methods ============
+  /**
+   * Clear all moderation data (for testing)
+   */
+  async clear() {
+    await this.db.prepare(`DELETE FROM ${this.prefix}_reports`).run();
+    await this.db.prepare(`DELETE FROM ${this.prefix}_actions`).run();
+    await this.db.prepare(`DELETE FROM ${this.prefix}_blocks`).run();
+    await this.db.prepare(`DELETE FROM ${this.prefix}_policies`).run();
+    await this.db.prepare(`DELETE FROM ${this.prefix}_rate_limits`).run();
+  }
+  /**
+   * Get stats for dashboard
+   */
+  async getStats() {
+    const [reportsTotal, reportsPending, actionsTotal, actionsActive, blocksTotal, blocksActive, policiesTotal, policiesEnabled] = await Promise.all([
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_reports`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_reports WHERE status = 'pending'`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_actions`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_actions WHERE active = 1`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_blocks`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_blocks WHERE active = 1`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_policies`).first(),
+      this.db.prepare(`SELECT COUNT(*) as count FROM ${this.prefix}_policies WHERE enabled = 1`).first()
+    ]);
+    return {
+      reports: { total: reportsTotal?.count ?? 0, pending: reportsPending?.count ?? 0 },
+      actions: { total: actionsTotal?.count ?? 0, active: actionsActive?.count ?? 0 },
+      blocks: { total: blocksTotal?.count ?? 0, active: blocksActive?.count ?? 0 },
+      policies: { total: policiesTotal?.count ?? 0, enabled: policiesEnabled?.count ?? 0 }
+    };
+  }
+  // ============ Row Converters ============
+  rowToReport(row) {
+    return {
+      id: row.id,
+      reporterActorId: row.reporter_actor_id,
+      reporterInstance: row.reporter_instance,
+      targetIds: JSON.parse(row.target_ids),
+      category: row.category,
+      description: row.description,
+      status: row.status,
+      activityId: row.activity_id,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      receivingInstance: row.receiving_instance,
+      federatedToTarget: row.federated_to_target === 1,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }
+  rowToAction(row) {
+    return {
+      id: row.id,
+      reportId: row.report_id ?? void 0,
+      moderatorActorId: row.moderator_actor_id,
+      targetId: row.target_id,
+      actionType: row.action_type,
+      reason: row.reason,
+      timestamp: row.timestamp,
+      expiresAt: row.expires_at ?? void 0,
+      active: row.active === 1,
+      reversesActionId: row.reverses_action_id ?? void 0,
+      approvedBy: row.approved_by ? JSON.parse(row.approved_by) : void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }
+  rowToBlock(row) {
+    return {
+      id: row.id,
+      blockedDomain: row.blocked_domain,
+      level: row.level,
+      reason: row.reason,
+      createdBy: row.created_by,
+      createdAt: row.created_at,
+      active: row.active === 1,
+      publicComment: row.public_comment ?? void 0,
+      federate: row.federate === 1
+    };
+  }
+  rowToPolicy(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      rules: JSON.parse(row.rules),
+      enabled: row.enabled === 1,
+      defaultAction: row.default_action,
+      updatedAt: row.updated_at
+    };
+  }
+  rowToRateLimit(row) {
+    return {
+      actorId: row.actor_id,
+      tokens: row.tokens,
+      maxTokens: row.max_tokens,
+      lastRefill: row.last_refill,
+      refillRate: row.refill_rate
+    };
+  }
+};
+var DEFAULT_TARGET_FIELDS = ["name", "description", "personality", "scenario", "first_mes"];
+var MAX_REGEX_INPUT_LENGTH = 1e5;
+var MAX_REGEX_PATTERN_LENGTH = 1e3;
+var REDOS_WARNING_PATTERNS = [
+  /\(\.\*\)\+/,
+  // (.*)+
+  /\(\.\+\)\+/,
+  // (.+)+
+  /\([^)]*\+[^)]*\)\+/,
+  // (a+)+ style nested quantifiers
+  /\([^)]*\*[^)]*\)\*/,
+  // (a*)* style nested quantifiers
+  /\(\[.*?\]\+\)\+/
+  // ([a-z]+)+ character class with nested quantifiers
+];
+function checkRegexSafety(pattern) {
+  if (pattern.length > MAX_REGEX_PATTERN_LENGTH) {
+    return `Pattern too long (${pattern.length} chars, max ${MAX_REGEX_PATTERN_LENGTH})`;
+  }
+  for (const dangerousPattern of REDOS_WARNING_PATTERNS) {
+    if (dangerousPattern.test(pattern)) {
+      return `Pattern may be vulnerable to ReDoS (catastrophic backtracking): matches ${dangerousPattern}`;
+    }
+  }
+  return null;
+}
+var PolicyEngine = class {
+  store;
+  compiledRegexCache = /* @__PURE__ */ new Map();
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Evaluate a card against all active policies
+   *
+   * @param card - The CCv3 card to evaluate
+   * @param sourceInstance - Optional source instance domain for instance rules
+   * @returns Evaluation result with action and matched rules
+   */
+  async evaluateCard(card, sourceInstance) {
+    const policies = await this.store.listPolicies({ enabled: true });
+    const allMatches = [];
+    let finalAction = "allow";
+    let lowestPriority = Infinity;
+    for (const policy of policies) {
+      const result = this.evaluateAgainstPolicy(card, policy, sourceInstance);
+      allMatches.push(...result.matchedRules);
+      for (const match of result.matchedRules) {
+        const rule = policy.rules.find((r) => r.id === match.ruleId);
+        if (rule && rule.priority < lowestPriority) {
+          lowestPriority = rule.priority;
+          finalAction = rule.action;
+          if (rule.action === "allow") {
+            return {
+              action: "allow",
+              matchedRules: allMatches,
+              hasMatch: true
+            };
+          }
+        }
+      }
+    }
+    if (allMatches.length === 0) {
+      const defaultAction = policies.length > 0 ? policies[0].defaultAction : "allow";
+      return {
+        action: defaultAction,
+        matchedRules: [],
+        hasMatch: false
+      };
+    }
+    return {
+      action: finalAction,
+      matchedRules: allMatches,
+      hasMatch: true
+    };
+  }
+  /**
+   * Evaluate card against a single policy
+   */
+  evaluateAgainstPolicy(card, policy, sourceInstance) {
+    const matches = [];
+    const enabledRules = policy.rules.filter((r) => r.enabled).sort((a, b) => a.priority - b.priority);
+    for (const rule of enabledRules) {
+      const match = this.evaluateRule(card, rule, sourceInstance);
+      if (match) {
+        matches.push({
+          ruleId: rule.id,
+          ruleName: rule.name,
+          matchedField: match.field,
+          matchedValue: match.value
+        });
+        if (rule.action === "allow") {
+          return { action: "allow", matchedRules: matches, hasMatch: true };
+        }
+      }
+    }
+    return {
+      action: matches.length > 0 ? enabledRules.find((r) => matches.some((m) => m.ruleId === r.id))?.action ?? policy.defaultAction : policy.defaultAction,
+      matchedRules: matches,
+      hasMatch: matches.length > 0
+    };
+  }
+  /**
+   * Evaluate a single rule against a card
+   */
+  evaluateRule(card, rule, sourceInstance) {
+    switch (rule.type) {
+      case "keyword":
+        return this.evaluateKeywordRule(card, rule);
+      case "regex":
+        return this.evaluateRegexRule(card, rule);
+      case "tag":
+        return this.evaluateTagRule(card, rule);
+      case "creator":
+        return this.evaluateCreatorRule(card, rule);
+      case "instance":
+        return this.evaluateInstanceRule(sourceInstance, rule);
+      default:
+        return null;
+    }
+  }
+  /**
+   * Keyword rule - case-insensitive text search
+   */
+  evaluateKeywordRule(card, rule) {
+    const keyword = rule.pattern.toLowerCase();
+    const fields = rule.targetFields || DEFAULT_TARGET_FIELDS;
+    for (const field of fields) {
+      const value = this.getCardField(card, field);
+      if (typeof value === "string" && value.toLowerCase().includes(keyword)) {
+        return { field, value: keyword };
+      }
+    }
+    return null;
+  }
+  /**
+   * Regex rule - pattern matching with compiled cache
+   *
+   * @security Input is truncated to MAX_REGEX_INPUT_LENGTH to prevent ReDoS.
+   * Patterns should be admin-audited. Use checkRegexSafety() when creating rules.
+   */
+  evaluateRegexRule(card, rule) {
+    let regex = this.compiledRegexCache.get(rule.id);
+    if (!regex) {
+      const safetyWarning = checkRegexSafety(rule.pattern);
+      if (safetyWarning) {
+        console.warn(`[moderation] Rule "${rule.name}": ${safetyWarning}`);
+      }
+      try {
+        regex = new RegExp(rule.pattern, "i");
+        this.compiledRegexCache.set(rule.id, regex);
+      } catch {
+        return null;
+      }
+    }
+    const fields = rule.targetFields || DEFAULT_TARGET_FIELDS;
+    for (const field of fields) {
+      const value = this.getCardField(card, field);
+      if (typeof value === "string") {
+        const truncatedValue = value.length > MAX_REGEX_INPUT_LENGTH ? value.slice(0, MAX_REGEX_INPUT_LENGTH) : value;
+        const match = truncatedValue.match(regex);
+        if (match) {
+          return { field, value: match[0] };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Tag rule - check card tags array
+   */
+  evaluateTagRule(card, rule) {
+    const tags = card.data.tags || [];
+    const targetTag = rule.pattern.toLowerCase();
+    const found = tags.find((t) => t.toLowerCase() === targetTag);
+    if (found) {
+      return { field: "tags", value: found };
+    }
+    return null;
+  }
+  /**
+   * Creator rule - match card creator
+   */
+  evaluateCreatorRule(card, rule) {
+    const creator = card.data.creator?.toLowerCase() || "";
+    if (creator === rule.pattern.toLowerCase()) {
+      return { field: "creator", value: creator };
+    }
+    return null;
+  }
+  /**
+   * Instance rule - match source domain
+   * Supports wildcard patterns like "*.evil.com"
+   */
+  evaluateInstanceRule(sourceInstance, rule) {
+    if (!sourceInstance) return null;
+    const domain = sourceInstance.toLowerCase();
+    const pattern = rule.pattern.toLowerCase();
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(2);
+      if (domain.endsWith(suffix) || domain === suffix) {
+        return { field: "instance", value: domain };
+      }
+    } else if (domain === pattern) {
+      return { field: "instance", value: domain };
+    }
+    return null;
+  }
+  /**
+   * Get a field value from card data
+   */
+  getCardField(card, field) {
+    if (field.includes(".")) {
+      const parts = field.split(".");
+      let value = card.data;
+      for (const part of parts) {
+        if (value && typeof value === "object" && part in value) {
+          value = value[part];
+        } else {
+          return void 0;
+        }
+      }
+      return value;
+    }
+    return card.data[field];
+  }
+  /**
+   * Clear regex cache (call when rules change)
+   */
+  clearCache() {
+    this.compiledRegexCache.clear();
+  }
+  /**
+   * Pre-compile regexes for a policy (optimization)
+   *
+   * @returns errors for invalid patterns, warnings for potentially unsafe patterns
+   */
+  precompilePolicy(policy) {
+    const errors = [];
+    const warnings = [];
+    for (const rule of policy.rules) {
+      if (rule.type === "regex" && rule.enabled) {
+        const safetyWarning = checkRegexSafety(rule.pattern);
+        if (safetyWarning) {
+          warnings.push(`Rule "${rule.name}": ${safetyWarning}`);
+        }
+        try {
+          const regex = new RegExp(rule.pattern, "i");
+          this.compiledRegexCache.set(rule.id, regex);
+        } catch (err) {
+          errors.push(`Rule "${rule.name}" has invalid regex: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+    return { errors, warnings };
+  }
+};
+var DEFAULT_CONFIG = {
+  maxTokens: 5,
+  refillRate: 1
+};
+var RateLimiter = class {
+  store;
+  config;
+  constructor(store, config) {
+    this.store = store;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /**
+   * Check if action is allowed and consume a token if so
+   *
+   * @param actorId - Actor URI to check
+   * @returns Rate limit result with remaining tokens and reset time
+   */
+  async checkAndConsume(actorId) {
+    let bucket = await this.store.getRateLimitBucket(actorId);
+    if (!bucket) {
+      bucket = {
+        actorId,
+        tokens: this.config.maxTokens,
+        maxTokens: this.config.maxTokens,
+        lastRefill: (/* @__PURE__ */ new Date()).toISOString(),
+        refillRate: this.config.refillRate
+      };
+    }
+    bucket = this.refillBucket(bucket);
+    if (bucket.tokens < 1) {
+      const resetAt = this.calculateResetTime(bucket);
+      const retryAfter = Math.ceil((new Date(resetAt).getTime() - Date.now()) / 1e3);
+      await this.store.updateRateLimitBucket(bucket);
+      return {
+        allowed: false,
+        remaining: 0,
+        resetAt,
+        retryAfter: Math.max(0, retryAfter)
+      };
+    }
+    bucket.tokens -= 1;
+    await this.store.updateRateLimitBucket(bucket);
+    return {
+      allowed: true,
+      remaining: Math.floor(bucket.tokens),
+      resetAt: this.calculateResetTime(bucket)
+    };
+  }
+  /**
+   * Check remaining tokens without consuming
+   *
+   * @param actorId - Actor URI to check
+   * @returns Current rate limit status
+   */
+  async check(actorId) {
+    let bucket = await this.store.getRateLimitBucket(actorId);
+    if (!bucket) {
+      return {
+        allowed: true,
+        remaining: this.config.maxTokens,
+        resetAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    bucket = this.refillBucket(bucket);
+    return {
+      allowed: bucket.tokens >= 1,
+      remaining: Math.floor(bucket.tokens),
+      resetAt: this.calculateResetTime(bucket),
+      retryAfter: bucket.tokens < 1 ? Math.ceil((new Date(this.calculateResetTime(bucket)).getTime() - Date.now()) / 1e3) : void 0
+    };
+  }
+  /**
+   * Reset rate limit for an actor (admin function)
+   *
+   * @param actorId - Actor URI to reset
+   */
+  async reset(actorId) {
+    const bucket = {
+      actorId,
+      tokens: this.config.maxTokens,
+      maxTokens: this.config.maxTokens,
+      lastRefill: (/* @__PURE__ */ new Date()).toISOString(),
+      refillRate: this.config.refillRate
+    };
+    await this.store.updateRateLimitBucket(bucket);
+  }
+  /**
+   * Refill tokens based on time elapsed since last refill
+   */
+  refillBucket(bucket) {
+    const now = /* @__PURE__ */ new Date();
+    const lastRefill = new Date(bucket.lastRefill);
+    const hoursSinceRefill = (now.getTime() - lastRefill.getTime()) / (1e3 * 60 * 60);
+    const tokensToAdd = hoursSinceRefill * bucket.refillRate;
+    if (tokensToAdd >= 1) {
+      bucket.tokens = Math.min(bucket.maxTokens, bucket.tokens + Math.floor(tokensToAdd));
+      bucket.lastRefill = now.toISOString();
+    }
+    return bucket;
+  }
+  /**
+   * Calculate when bucket will have at least 1 token
+   */
+  calculateResetTime(bucket) {
+    if (bucket.tokens >= bucket.maxTokens) {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+    const tokensNeeded = Math.max(0, 1 - bucket.tokens);
+    const hoursUntilToken = tokensNeeded / bucket.refillRate;
+    const msUntilToken = hoursUntilToken * 60 * 60 * 1e3;
+    const lastRefill = new Date(bucket.lastRefill);
+    return new Date(lastRefill.getTime() + msUntilToken).toISOString();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var explicitlyEnabled = false;
+var envCheckSkipped = false;
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process?.env) {
+    return process.env[name];
+  }
+  return void 0;
+}
+function enableFederation(options) {
+  explicitlyEnabled = true;
+  envCheckSkipped = options?.skipEnvCheck ?? false;
+  const nodeEnv = getEnvVar("NODE_ENV");
+  if (nodeEnv === "development" || nodeEnv === "test") {
+    console.warn(
+      "[character-foundry/federation] Federation enabled. WARNING: Verify HTTP signatures in production. Do NOT use in production with untrusted inputs without signature validation."
+    );
+  }
+}
+function isFederationEnabled() {
+  if (!explicitlyEnabled) {
+    return false;
+  }
+  if (envCheckSkipped) {
+    return true;
+  }
+  const envEnabled = getEnvVar("FEDERATION_ENABLED") === "true";
+  return envEnabled;
+}
+function assertFederationEnabled(feature) {
+  if (!explicitlyEnabled) {
+    const hasProcess = typeof process !== "undefined" && process?.env;
+    const envHint = hasProcess ? "You must BOTH call enableFederation() AND set FEDERATION_ENABLED=true." : "You must call enableFederation({ skipEnvCheck: true }) in browser/Workers environments.";
+    throw new Error(
+      `Federation is not enabled. ${feature} requires federation to be explicitly enabled. ${envHint} WARNING: Federation security features are incomplete.`
+    );
+  }
+  if (envCheckSkipped) {
+    return;
+  }
+  const envEnabled = getEnvVar("FEDERATION_ENABLED") === "true";
+  if (!envEnabled) {
+    throw new Error(
+      `FEDERATION_ENABLED environment variable not set. ${feature} requires FEDERATION_ENABLED=true. Code opt-in alone is not sufficient (dual opt-in required). In browser/Workers, use enableFederation({ skipEnvCheck: true }) instead.`
+    );
+  }
+}
+export {
+  ACTIVITY_CONTEXT,
+  BasePlatformAdapter,
+  D1ModerationStore,
+  D1SyncStateStore,
+  FORK_ACTIVITY_CONTEXT,
+  FileSyncStateStore,
+  HttpPlatformAdapter,
+  INSTALL_ACTIVITY_CONTEXT,
+  InvalidResourceIdError,
+  MODERATION_ACTIVITY_CONTEXT,
+  MemoryModerationStore,
+  MemoryPlatformAdapter,
+  MemorySyncStateStore,
+  PolicyEngine,
+  REQUIRED_SIGNED_HEADERS,
+  RateLimiter,
+  SillyTavernAdapter,
+  SyncEngine,
+  assertFederationEnabled,
+  buildSigningString,
+  buildSigningStringStrict,
+  calculateDigest,
+  cardFromActivityPub,
+  cardToActivityPub,
+  ccv3ToSTCharacter,
+  checkRegexSafety,
+  createActor,
+  createAnnounceActivity,
+  createArchiveAdapter,
+  createBlockActivity,
+  createCreateActivity,
+  createDeleteActivity,
+  createFlagActivity,
+  createForkActivity,
+  createHubAdapter,
+  createInstallActivity,
+  createLikeActivity,
+  createLocalStorageStore,
+  createMockSTBridge,
+  createUndoActivity,
+  createUpdateActivity,
+  enableFederation,
+  generateActivityId,
+  generateCardId,
+  handleActor,
+  handleInbox,
+  handleNodeInfo,
+  handleNodeInfoDiscovery,
+  handleWebFinger,
+  isFederationEnabled,
+  parseActivity,
+  parseBlockActivity,
+  parseFlagActivity,
+  parseForkActivity,
+  parseInstallActivity,
+  parseSignatureHeader,
+  signRequest,
+  stCharacterToCCv3,
+  validateBlockActivity as validateBlockActivityFields,
+  validateFlagActivity as validateFlagActivityFields,
+  validateForkActivity,
+  validateActivitySignature as validateHttpSignature,
+  validateInstallActivity,
+  verifyHttpSignature
+};
 //# sourceMappingURL=federation.js.map