@takosjp/yurucommu-core 3.4.1 → 3.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takosjp/yurucommu-core",
-  "version": "3.4.1",
+  "version": "3.4.3",
   "license": "AGPL-3.0-only",
   "type": "module",
   "workspaces": [

package/packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takosjp/yurucommu-api",
-  "version": "3.4.0",
+  "version": "3.4.3",
   "description": "Typed client SDK and public API contract for yurucommu-server clients.",
   "license": "AGPL-3.0-only",
   "type": "module",

package/src/backend/index.ts

@@ -56,6 +56,7 @@ import type {
   MessageBatch,
   Queue,
   R2Bucket,
+  ScheduledController,
 } from "@cloudflare/workers-types";
 import type {
   DeliveryDlqMessageV1,
@@ -66,6 +67,7 @@ import {
   handleDeliveryQueueBatch,
 } from "./lib/delivery/queue.ts";
 import { enqueuePendingNotificationPushJobs } from "./lib/notification-push.ts";
+import { runYurucommuRetention } from "./retention.ts";
 
 type YurucommuApp = Hono<{ Bindings: Env; Variables: Variables }>;
 
@@ -994,6 +996,12 @@ type WorkerBindings = EnvVars & {
   REALTIME_STREAM?: DurableObjectNamespace;
 };
 
+function isMaterializedRuntimeEnv(
+  bindings: WorkerBindings | Env,
+): bindings is Env {
+  return "DB_INSTANCE" in bindings && !!bindings.DB_INSTANCE;
+}
+
 export default {
   async fetch(
     request: Request,
@@ -1012,4 +1020,15 @@ export default {
       wrapCloudflareBindings(bindings),
     );
   },
+
+  async scheduled(
+    _controller: ScheduledController,
+    bindings: WorkerBindings | Env,
+    _ctx: ExecutionContext,
+  ): Promise<void> {
+    const env = isMaterializedRuntimeEnv(bindings)
+      ? bindings
+      : wrapCloudflareBindings(bindings);
+    await runYurucommuRetention(env);
+  },
 };

package/src/backend/public.ts

@@ -9,6 +9,12 @@ export {
   type YurucommuBackendDiscoveryOptionsV1,
   type YurucommuBackendPluginV1,
 } from "./index.ts";
+export {
+  runYurucommuRetention,
+  YurucommuRetentionError,
+  type YurucommuRetentionResult,
+  type YurucommuRetentionStep,
+} from "./retention.ts";
 export { default } from "./index.ts";
 export { default as app } from "./index.ts";
 export { type Database, getDb, getDbSQLite } from "../db/index.ts";
@@ -19,7 +25,10 @@ export {
 } from "./runtime/cloudflare.ts";
 export {
   ManagedRuntimeGatewayError,
+  createManagedRuntimeKeyValueStore,
+  createManagedRuntimeObjectStorage,
   createManagedRuntimeQueueProducer,
+  type ManagedRuntimeDataAdapterOptions,
   type ManagedRuntimeGateway,
   type ManagedRuntimeQueueProducerOptions,
 } from "./runtime/managed-runtime.ts";
@@ -27,6 +36,13 @@ export {
   createManagedRelationalDatabase,
   type ManagedRelationalDatabaseOptions,
 } from "./runtime/managed-relational.ts";
+export type {
+  IKeyValueStore,
+  IObjectStorage,
+  ListObjectsResult,
+  ObjectMetadata,
+  StorageObject,
+} from "./runtime/types.ts";
 export type {
   IQueueBatch,
   IQueueMessage,

package/src/backend/retention.ts

@@ -0,0 +1,78 @@
+import type { Env } from "./types.ts";
+import { enqueuePendingNotificationPushJobs } from "./lib/notification-push.ts";
+import { reapDrainedTombstones } from "./routes/actors.ts";
+import { cleanupExpiredStories } from "./routes/stories/query-helpers.ts";
+
+export type YurucommuRetentionStep =
+  "expired_stories" | "drained_tombstones" | "notification_push";
+
+export interface YurucommuRetentionResult {
+  readonly expiredStories: number;
+  readonly reapedTombstones: number;
+  readonly enqueuedNotificationPushJobs: number;
+}
+
+/**
+ * Identifies the exact bounded retention step that failed. Scheduled callers
+ * must reject the invocation instead of treating a partial or skipped sweep as
+ * success; the original database/runtime error remains available as `cause`.
+ */
+export class YurucommuRetentionError extends Error {
+  constructor(
+    readonly step: YurucommuRetentionStep,
+    cause: unknown,
+  ) {
+    super(`yurucommu retention failed at ${step}`, { cause });
+    this.name = "YurucommuRetentionError";
+  }
+}
+
+/**
+ * Run one bounded retention pass against the already-materialized runtime.
+ *
+ * This deliberately reuses the same race-safe cleanup paths as request/queue
+ * handling:
+ * - Story expiry uses the canonical object cascade and purges its media last.
+ * - Tombstones remain until every Delete delivery has drained.
+ * - Notification push performs bounded pusher/job retention, stale-job
+ *   recovery, and enqueues due durable outbox rows when a queue is available.
+ *
+ * Steps are awaited sequentially because D1 is the shared authority. Any
+ * failure rejects with its exact step; callers must retry the cron invocation
+ * rather than silently acknowledging incomplete retention.
+ */
+export async function runYurucommuRetention(
+  env: Env,
+): Promise<YurucommuRetentionResult> {
+  if (!env?.DB_INSTANCE) {
+    throw new TypeError("Yurucommu retention requires DB_INSTANCE");
+  }
+
+  const expiredStories = await retentionStep("expired_stories", () =>
+    cleanupExpiredStories(env.DB_INSTANCE, env.MEDIA),
+  );
+  const reapedTombstones = await retentionStep("drained_tombstones", () =>
+    reapDrainedTombstones(env.DB_INSTANCE),
+  );
+  const enqueuedNotificationPushJobs = await retentionStep(
+    "notification_push",
+    () => enqueuePendingNotificationPushJobs(env),
+  );
+
+  return {
+    expiredStories,
+    reapedTombstones,
+    enqueuedNotificationPushJobs,
+  };
+}
+
+async function retentionStep<T>(
+  step: YurucommuRetentionStep,
+  run: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await run();
+  } catch (cause) {
+    throw new YurucommuRetentionError(step, cause);
+  }
+}

package/src/backend/routes/actors.ts

@@ -286,11 +286,11 @@ export async function cancelTombstoneDelete(
   return deleteActivityIds.length;
 }
 
-// Best-effort, opportunistic tombstone reaping on the read path. This Worker
-// has no `scheduled` handler, so (mirroring maybeCleanupExpiredStories) the
-// sweep is triggered probabilistically and guarded so at most one runs per
-// isolate at a time. Tombstones are already excluded from every serving query,
-// so a missed sweep only delays storage/key-material reclamation.
+// Best-effort, opportunistic tombstone reaping on the read path. The public
+// Worker has a scheduled retention handler too; this remains as a fallback for
+// self-hosted runtimes without cron. It is guarded so at most one pass runs per
+// isolate. Tombstones are already excluded from every serving query, so a
+// missed sweep only delays storage/key-material reclamation.
 let tombstoneReapInFlight = false;
 
 export function maybeReapDrainedTombstones(db: Database): void {

package/src/backend/routes/stories/routes.ts

@@ -62,13 +62,11 @@ const stories = new Hono<{ Bindings: Env; Variables: Variables }>();
 
 // Best-effort, opportunistic retention of expired stories.
 //
-// This is NOT a substitute for a scheduled job: this Worker has no `scheduled`
-// handler / cron trigger, so expiry cleanup is triggered probabilistically on
-// the read path. Expired stories are already excluded from every read query
-// (the feed/single-story handlers filter on `endTime`), so the only impact of
-// a missed sweep is storage growth, not stale data leaking to users. The guard
-// below ensures at most one sweep runs at a time per isolate, so a burst of
-// feed requests cannot kick off several concurrent full-table delete sweeps.
+// The public Worker also exposes a scheduled retention handler. Keep this
+// probabilistic read-path pass as a self-hosting fallback for runtimes that do
+// not configure a cron trigger. Expired stories are already excluded from every
+// read query, so a missed sweep affects storage only. The guard below ensures
+// at most one fallback pass runs at a time per isolate.
 let expiredStoryCleanupInFlight = false;
 
 function maybeCleanupExpiredStories(