npm - @lunora/platform - Versions diffs - 0.0.0 → 1.0.0-alpha.2 - Mend

@lunora/platform 0.0.0 → 1.0.0-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/LICENSE.md +111 -0
package/README.md +11 -37
package/dist/conformance/index.d.mts +2 -0
package/dist/conformance/index.d.ts +2 -0
package/dist/conformance/index.mjs +1 -0
package/dist/conformance/suite.d.mts +132 -0
package/dist/conformance/suite.d.ts +132 -0
package/dist/conformance/suite.mjs +1 -0
package/dist/index.d.mts +563 -0
package/dist/index.d.ts +563 -0
package/dist/index.mjs +1 -0
package/dist/packem_shared/CLOUDFLARE_CAPABILITIES-CfXSyHOn.mjs +1 -0
package/dist/packem_shared/NOOP_EXECUTION_CONTEXT-YmXqH-jH.mjs +1 -0
package/dist/packem_shared/createReferenceHost-GO8Hp4ft.mjs +1 -0
package/dist/packem_shared/resolveShard-uGhAKuTB.mjs +1 -0
package/dist/packem_shared/socket-host.d-Cq5uVbiH.d.mts +580 -0
package/dist/packem_shared/socket-host.d-Cq5uVbiH.d.ts +580 -0
package/package.json +53 -7

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,563 @@
+export { type D as DirectShardDirectory, type S as ScheduleOptions, type a as ScheduledJob, type b as ScheduledJobStatus, type c as SchedulerHost, type d as ShardAlarms, type e as ShardAsyncSqlExec, type f as ShardDirectory, type g as ShardHost, type h as ShardJurisdiction, type i as ShardKvListOptions, type j as ShardKvStore, type k as ShardSqlCursor, type l as ShardSqlExec, type m as ShardStub, type n as SocketHandle, type o as SocketHost, type p as SqlRow, type T as TwoStepShardDirectory, r as resolveShard } from "./packem_shared/socket-host.d-Cq5uVbiH.js";
+/**
+ * The subset of the Cloudflare `ExecutionContext` the Lunora worker entry and
+ * the framework mount seams rely on — `waitUntil` for fire-and-forget work that
+ * must outlive the response, and `passThroughOnException` for the top-level
+ * error posture.
+ *
+ * It is deliberately **not** a package. `@lunora/runtime` is the leaf server
+ * runtime and `@lunora/nuxt` is a framework integration that intentionally does
+ * not depend on `@lunora/runtime`'s worker types, yet both need this exact
+ * shape: the runtime to build/forward the worker `fetch`, Nuxt to forward an
+ * inbound request to the user's composed worker. Each imports this file by
+ * relative path and the bundler (packem/rollup) inlines it: no runtime
+ * dependency edge is created, the helper is duplicated only in emitted output,
+ * never in source. One source of truth, zero deps. See AGENTS.md → "Top-level
+ * `shared/` — bundler-inlined source".
+ *
+ * Both methods are **optional**: a real Cloudflare `ExecutionContext` always
+ * supplies them, but a host that mounts Lunora as a sub-handler (Nitro/H3, a
+ * non-Cloudflare preview, a unit test) may hand over a partial context or none
+ * at all. Callers therefore invoke them defensively (`ctx.waitUntil?.(…)`) or
+ * fall back to {@link NOOP_EXECUTION_CONTEXT}.
+ */
+interface ExecutionContextLike {
+  cache?: {
+    purge: (options: {
+      purgeEverything?: boolean;
+      tags?: string[];
+    }) => Promise<unknown>;
+  };
+  passThroughOnException?: () => void;
+  waitUntil?: (promise: Promise<unknown>) => void;
+}
+/**
+ * No-op `ExecutionContext` used when the host runtime didn't supply one (a
+ * non-Cloudflare preview, or a unit test), so the worker's `fetch` always
+ * receives a valid third argument.
+ */
+declare const NOOP_EXECUTION_CONTEXT: ExecutionContextLike;
+/**
+ * Canonical provider-neutral binding projections. These mirror the existing
+ * per-package `*Like` types; in later phases each package's copy becomes a
+ * type-only re-export of these canonical definitions.
+ *
+ * For now, this module is additive: existing packages keep their local copies
+ * unchanged, so Phase 0 carries zero runtime or type-breaking risk.
+ */
+/** Per-message send options. */
+interface QueueSendOptionsLike {
+  delaySeconds?: number;
+}
+/** One message in a batch send. */
+interface QueueSendRequestLike<Body = unknown> {
+  body: Body;
+  delaySeconds?: number;
+}
+/** One delivered queue message (consumer side). */
+interface QueueMessageLike<Body = unknown> {
+  ack: () => void;
+  readonly attempts: number;
+  readonly body: Body;
+  readonly id: string;
+  retry: (options?: {
+    delaySeconds?: number;
+  }) => void;
+  readonly timestamp: Date;
+}
+/** A single vector match. */
+interface VectorMatchLike {
+  id: string;
+  metadata?: Record<string, unknown>;
+  score: number;
+}
+/** Vector query/upsert record. */
+interface VectorRecordLike {
+  id: string;
+  metadata?: Record<string, unknown>;
+  values: number[];
+}
+/** A single analytics data point. */
+interface AnalyticsEngineDataPointLike {
+  blobs?: string[];
+  doubles?: number[];
+  indexes?: string[];
+}
+interface D1PreparedStatementLike {
+  all: <T = unknown>() => Promise<{
+    results: T[];
+    success: boolean;
+  }>;
+  bind: (...values: unknown[]) => D1PreparedStatementLike;
+  first: <T = unknown>(column?: string) => Promise<T | null>;
+  raw: <T = unknown>() => Promise<T[][]>;
+  run: <T = unknown>() => Promise<{
+    meta?: Record<string, unknown>;
+    results?: T[];
+    success: boolean;
+  }>;
+}
+interface D1SessionLike {
+  batch?: (statements: D1PreparedStatementLike[]) => Promise<unknown[]>;
+  getBookmark: () => string | null;
+  prepare: (sql: string) => D1PreparedStatementLike;
+}
+/**
+ * Minimal structural projection of `D1Database` to keep the adapter
+ * compatible with the real workers-types value as well as unit-test doubles.
+ */
+interface D1DatabaseLike {
+  batch?: (statements: D1PreparedStatementLike[]) => Promise<unknown[]>;
+  prepare: (sql: string) => D1PreparedStatementLike;
+  withSession: (bookmark?: string) => D1SessionLike;
+}
+/**
+ * One Analytics Engine data point, mirroring the positional shape
+ * `writeDataPoint` accepts. AE stores up to 20 string `blobs`, up to 20 numeric
+ * `doubles`, and exactly **one** `index` (the high-cardinality sampling key) per
+ * data point — the SQL API later exposes them as `blob1..blob20`,
+ * `double1..double20`, and `index1`.
+ */
+interface AnalyticsEngineDataPoint {
+  /** String columns, mapped positionally to `blob1..blob20`. */
+  blobs?: (ArrayBuffer | null | string)[];
+  /** Numeric columns, mapped positionally to `double1..double20`. */
+  doubles?: number[];
+  /** Sampling key, exposed as `index1`. AE accepts at most one. */
+  indexes?: (ArrayBuffer | string)[];
+}
+/**
+ * Minimal structural projection of workers-types' `AnalyticsEngineDataset`,
+ * kept loose enough for a plain-object fake in unit tests. `writeDataPoint` is
+ * fire-and-forget: it returns `void` and never throws on the hot path.
+ */
+interface AnalyticsEngineDatasetLike {
+  writeDataPoint: (event: AnalyticsEngineDataPoint) => void;
+}
+/**
+ * The value types Workers KV can store / return. Mirrors Cloudflare's
+ * `KVNamespace` `get`/`put` body unions; declared here so the package stays
+ * runtime-agnostic and the `*Like` interfaces don't pull in
+ * `@cloudflare/workers-types` at runtime.
+ */
+type KvValue = ReadableStream | ArrayBuffer | ArrayBufferView | string;
+/** How a raw KV read should decode the stored value. Mirrors KV's `type` option. */
+type KvValueType = "text" | "json" | "arrayBuffer" | "stream";
+/**
+ * Per-read options forwarded to the binding. `cacheTtl` is KV's edge-cache TTL
+ * (seconds, min 60); `type` selects the decode mode for `Kv.getRaw` (in `@lunora/bindings/kv`).
+ */
+interface KvGetOptions {
+  /** KV edge-cache TTL in seconds (minimum 60). Forwarded verbatim. */
+  cacheTtl?: number;
+  /** Decode mode for a raw read. `Kv.get` (in `@lunora/bindings/kv`) always uses `"json"`. */
+  type?: KvValueType;
+}
+/**
+ * Minimal projection of Cloudflare's `KVNamespace`. Declared structurally so
+ * unit tests can pass a plain `Map`-backed double; the real binding satisfies
+ * the same shape. Mirrors `R2BucketLike` in `@lunora/storage`.
+ */
+interface KVNamespaceLike {
+  /** Delete a key. No-op if the key is absent. */
+  delete: (key: string) => Promise<void>;
+  /**
+   * Read a value. The real binding overloads on `options.type`; declared here
+   * as the broad union so a structural double need only return the value (or
+   * `null` when absent).
+   */
+  get: (key: string, options?: KvGetOptions | KvValueType) => Promise<unknown>;
+  /**
+   * Read a value together with its associated metadata. Returns
+   * `{ value: null, metadata: null }` when the key is absent.
+   */
+  getWithMetadata: (key: string, options?: KvGetOptions | KvValueType) => Promise<{
+    metadata: unknown;
+    value: unknown;
+  }>;
+  /** List keys, optionally filtered by `prefix` and paginated via `cursor`. */
+  list: (options?: {
+    cursor?: string;
+    limit?: number;
+    prefix?: string;
+  }) => Promise<KvNamespaceListResult>;
+  /** Write a value, optionally with TTL/expiration and metadata. */
+  put: (key: string, value: KvValue, options?: KvNamespacePutOptions) => Promise<void>;
+}
+/** The raw put options the KV binding accepts (mirrors `KVNamespacePutOptions`). */
+interface KvNamespacePutOptions {
+  /** Absolute expiration as a Unix timestamp (seconds). Mutually exclusive with `expirationTtl`. */
+  expiration?: number;
+  /** Relative expiration in seconds from now (minimum 60). Mutually exclusive with `expiration`. */
+  expirationTtl?: number;
+  /** Arbitrary JSON metadata stored alongside the value, returned by `getWithMetadata`/`list`. */
+  metadata?: unknown;
+}
+/** One key entry as returned by the KV binding's `list`. */
+interface KvListKey<Metadata = unknown> {
+  /** Absolute expiration (Unix seconds), when the key has one. */
+  expiration?: number;
+  /** The key's metadata, when set at write time. */
+  metadata?: Metadata;
+  /** The key name. */
+  name: string;
+}
+/** The raw `list` result shape returned by the KV binding. */
+type KvNamespaceListResult<Metadata = unknown> = {
+  cacheStatus?: string | null;
+  cursor: string;
+  keys: KvListKey<Metadata>[];
+  list_complete: false;
+} | {
+  cacheStatus?: string | null;
+  keys: KvListKey<Metadata>[];
+  list_complete: true;
+};
+/**
+ * Minimal structural projection of `VectorizeIndex` so unit tests can pass a
+ * plain-object double and the real Cloudflare binding satisfies the same shape.
+ * Mirrors the surface documented at
+ * https://developers.cloudflare.com/vectorize/reference/client-api/.
+ */
+interface VectorizeIndexLike {
+  deleteByIds: (ids: ReadonlyArray<string>) => Promise<VectorizeDeleteMutation>;
+  describe?: () => Promise<VectorizeIndexDetails>;
+  getByIds: (ids: ReadonlyArray<string>) => Promise<ReadonlyArray<VectorizeVector>>;
+  insert: (vectors: ReadonlyArray<VectorizeVector>) => Promise<VectorizeUpsertMutation>;
+  query: (vector: ReadonlyArray<number>, options?: VectorizeQueryOptions) => Promise<VectorizeMatches>;
+  upsert: (vectors: ReadonlyArray<VectorizeVector>) => Promise<VectorizeUpsertMutation>;
+}
+type VectorMetric = "cosine" | "euclidean" | "dot-product";
+interface VectorizeVector {
+  id: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+  values: ReadonlyArray<number>;
+}
+interface VectorizeQueryOptions {
+  filter?: Record<string, unknown>;
+  namespace?: string;
+  returnMetadata?: "none" | "indexed" | "all";
+  returnValues?: boolean;
+  topK?: number;
+}
+interface VectorizeMatch {
+  id: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+  score: number;
+  values?: ReadonlyArray<number>;
+}
+interface VectorizeMatches {
+  count: number;
+  matches: ReadonlyArray<VectorizeMatch>;
+}
+interface VectorizeUpsertMutation {
+  mutationId: string;
+}
+interface VectorizeDeleteMutation {
+  count?: number;
+  mutationId: string;
+}
+interface VectorizeIndexDetails {
+  dimensions: number;
+  processedUpToDatetime?: string;
+  processedUpToMutation?: string;
+  vectorsCount: number;
+}
+/**
+ * A single-range read against R2: an `{ offset, length }` window (at least one
+ * bound required, mirroring R2's own `R2Range`) or a `{ suffix }` tail. The
+ * subset of `R2Range` that {@link Storage.download} forwards so a caller can
+ * stream just the bytes it needs instead of the whole object.
+ */
+type R2RangeLike = {
+  length: number;
+  offset?: number;
+} | {
+  length?: number;
+  offset: number;
+} | {
+  suffix: number;
+};
+/**
+ * Minimal projection of `R2Bucket`. Declared structurally so unit tests can
+ * pass a plain object double; the real binding satisfies the same shape.
+ */
+interface R2BucketLike {
+  /**
+   * Begin a multipart upload (R2 `createMultipartUpload`). Optional so existing
+   * test doubles still satisfy the type; {@link Storage.createMultipartUpload}
+   * throws a clear error when the binding lacks it.
+   */
+  createMultipartUpload?: (key: string, options?: {
+    customMetadata?: Record<string, string>;
+    httpMetadata?: {
+      contentType?: string;
+    };
+  }) => Promise<R2MultipartUploadLike>;
+  delete: (key: string) => Promise<void>;
+  get: (key: string, options?: {
+    range?: R2RangeLike;
+  }) => Promise<R2ObjectBodyLike | null>;
+  /**
+   * Fetch an object's metadata without its body (R2 HEAD). Returns `null` when
+   * the object is absent. Declared optional so existing test doubles that only
+   * implement `get`/`put`/`list`/`delete` still satisfy the type; callers that
+   * need metadata fall back to a 0-length ranged `get()` when `head` is absent.
+   */
+  head?: (key: string) => Promise<R2ObjectLike | null>;
+  list: (options?: {
+    cursor?: string;
+    delimiter?: string;
+    limit?: number;
+    prefix?: string;
+  }) => Promise<{
+    cursor?: string;
+    objects: R2ObjectLike[];
+    truncated?: boolean;
+  }>;
+  put: (key: string, body: ReadableStream | ArrayBuffer | Blob | string | null, options?: {
+    customMetadata?: Record<string, string>;
+    httpMetadata?: {
+      contentType?: string;
+    };
+  }) => Promise<R2ObjectLike>;
+  /** Resume an in-progress multipart upload by id (R2 `resumeMultipartUpload`). Optional; see {@link Storage.resumeMultipartUpload}. */
+  resumeMultipartUpload?: (key: string, uploadId: string) => R2MultipartUploadLike;
+}
+/** One uploaded multipart part — returned by `uploadPart`, required to `complete`. Mirrors R2's `R2UploadedPart`. */
+interface R2UploadedPartLike {
+  etag: string;
+  partNumber: number;
+}
+/**
+ * An in-progress multipart upload, mirroring R2's `R2MultipartUpload`. Each part
+ * (except the last) must be uniform in size. The object does not guarantee the
+ * underlying upload still exists — a parallel `complete`/`abort` can invalidate
+ * it — so wrap each call in error handling.
+ */
+interface R2MultipartUploadLike {
+  /** Abort the upload, discarding any uploaded parts. */
+  abort: () => Promise<void>;
+  /** Finish the upload from the collected parts; resolves to the stored object. */
+  complete: (uploadedParts: R2UploadedPartLike[]) => Promise<R2ObjectLike>;
+  /** The object key being assembled. */
+  readonly key: string;
+  /** The R2 upload id (persist it to resume across requests). */
+  readonly uploadId: string;
+  /** Upload one part (1-indexed); returns the `{ partNumber, etag }` to pass to `complete`. */
+  uploadPart: (partNumber: number, value: ArrayBuffer | ArrayBufferView | Blob | ReadableStream | string) => Promise<R2UploadedPartLike>;
+}
+interface R2ObjectLike {
+  /**
+   * R2-computed checksums. The real binding exposes `sha256` as an
+   * `ArrayBuffer` (present only when R2 stored a SHA-256 for the object);
+   * declared optional so fakes and non-checksummed objects type-check.
+   */
+  checksums?: {
+    sha256?: ArrayBuffer;
+  };
+  customMetadata?: Record<string, string>;
+  etag: string;
+  /**
+   * The quoted form of {@link R2ObjectLike.etag} (e.g. `"abc123"`), suitable
+   * for emitting directly as an HTTP `ETag` header. The real binding always
+   * provides it; declared optional so existing doubles that only set `etag`
+   * still type-check (callers fall back to quoting `etag`).
+   */
+  httpEtag?: string;
+  httpMetadata?: {
+    contentType?: string;
+  };
+  key: string;
+  /**
+   * Hex-encoded SHA-256 of the object body, surfaced by `download()`/`list()`
+   * when R2 carries a checksum (derived from {@link R2ObjectLike.checksums}).
+   */
+  sha256?: string;
+  /**
+   * Base64-encoded SHA-256 of the object body, surfaced alongside
+   * {@link R2ObjectLike.sha256} from the same checksum. Base64 is the encoding
+   * RFC 9530 digest headers (`Repr-Digest`/`Content-Digest`) require, so HTTP
+   * layers can emit a spec-compliant digest without re-deriving it.
+   */
+  sha256Base64?: string;
+  size: number;
+  /**
+   * When the object was written. The real binding exposes this as a `Date`;
+   * declared optional so fakes that omit it still type-check.
+   * {@link Storage.getMetadata} normalises it to epoch ms.
+   */
+  uploaded?: Date;
+}
+interface R2ObjectBodyLike extends R2ObjectLike {
+  arrayBuffer: () => Promise<ArrayBuffer>;
+  body: ReadableStream | null;
+  text: () => Promise<string>;
+}
+/** How a queue message body is serialized on the wire (Cloudflare default `"json"`). */
+type QueueContentType = "bytes" | "json" | "text" | "v8";
+/** Options for a single `producer.send(body, options?)`. */
+interface QueueSendOptions {
+  /** Wire serialization for this message (defaults to the queue's content type). */
+  contentType?: QueueContentType;
+  /** Per-message delivery delay in seconds (0–43200, i.e. up to 12 hours). */
+  delaySeconds?: number;
+}
+/** Options for a `producer.sendBatch(messages, options?)`. */
+interface QueueSendBatchOptions {
+  /** Delivery delay applied to the whole batch, in seconds. */
+  delaySeconds?: number;
+}
+/** One entry in a `sendBatch` call — a body plus optional per-message overrides. */
+interface MessageSendRequestLike<Body = unknown> {
+  body: Body;
+  contentType?: QueueContentType;
+  delaySeconds?: number;
+}
+/**
+ * Minimal structural projection of workers-types' `Queue&lt;Body>` (the producer
+ * binding). The real binding's `send`/`sendBatch` resolve to a metadata object;
+ * we widen the return to `Promise&lt;unknown>` so a plain-object fake satisfies it.
+ */
+interface QueueBindingLike<Body = unknown> {
+  send: (message: Body, options?: QueueSendOptions) => Promise<unknown>;
+  sendBatch: (messages: Iterable<MessageSendRequestLike<Body>>, options?: QueueSendBatchOptions) => Promise<unknown>;
+}
+/** Structural mirror of workers-types' `Message&lt;Body>` (one delivered message). */
+interface MessageLike<Body = unknown> {
+  /** Acknowledge this message so it is not redelivered. */
+  ack: () => void;
+  readonly attempts: number;
+  readonly body: Body;
+  readonly id: string;
+  /** Explicitly retry this message (optionally after a delay). */
+  retry: (options?: QueueRetryOptions) => void;
+  readonly timestamp: Date;
+}
+/** Structural mirror of workers-types' `MessageBatch&lt;Body>` handed to a consumer. */
+interface MessageBatchLike<Body = unknown> {
+  /** Acknowledge every message in the batch. */
+  ackAll: () => void;
+  readonly messages: ReadonlyArray<MessageLike<Body>>;
+  /** The queue name this batch was delivered from (`batch.queue`), used to route. */
+  readonly queue: string;
+  /** Retry every message in the batch (optionally after a delay). */
+  retryAll: (options?: QueueRetryOptions) => void;
+}
+/** Options for retrying a message / batch (`message.retry({ delaySeconds })`). */
+interface QueueRetryOptions {
+  delaySeconds?: number;
+}
+/**
+ * `PlatformCapabilities` — the capability matrix type that describes which
+ * Lunora features a target platform supports natively, emulates, or cannot
+ * support at all.
+ *
+ * Codegen consumes this matrix to omit unsupported `ctx.*` surfaces from
+ * emitted types and to emit diagnostics for features that need emulation.
+ * Docs and Studio also read it to show parity per target.
+ */
+/** Support level for a single feature on a target platform. */
+type CapabilityLevel = "native" | "emulated" | "unsupported";
+/** Metadata about a capability's support level. */
+interface Capability {
+  /** Whether the feature is native, emulated, or unsupported. */
+  level: CapabilityLevel;
+  /** Optional human-readable note (e.g. "requires AWS EventBridge", "limited to 1000 sockets"). */
+  note?: string;
+}
+/**
+ * The full capability matrix for a platform. Each key maps to a `ctx.*`
+ * feature or a subsystem; the value describes the target's support level.
+ */
+interface PlatformCapabilities {
+  /** Feature-level capabilities. */
+  features: {
+    /** AI inference (Workers AI / Bedrock / OpenAI). */
+    ai?: Capability;
+    /** Analytics / observability sinks. */
+    analytics?: Capability;
+    /** Browser rendering / headless browser. */
+    browser?: Capability;
+    /** Container execution (Cloudflare Containers / Fargate). */
+    containers?: Capability;
+    /** Cross-shard fan-out queries. */
+    crossShardFanout?: Capability;
+    /** Global (replicated) tables backed by a SQL store. */
+    globalTables?: Capability;
+    /** BYO database via connection pooling (Hyperdrive / RDS Proxy). */
+    hyperdrive?: Capability;
+    /** Key-value storage (KV / Redis / DynamoDB). */
+    keyValueStore?: Capability;
+    /** Local SQL execution inside a shard. */
+    localSql?: Capability;
+    /** Email sending (Resend / SES / etc). */
+    mail?: Capability;
+    /** Object storage (R2 / S3 / MinIO). */
+    objectStorage?: Capability;
+    /** Pipelines / streaming data. */
+    pipelines?: Capability;
+    /** Queue-backed workpools. */
+    queues?: Capability;
+    /** Cron triggers / scheduled functions. */
+    scheduler?: Capability;
+    /** Secrets management. */
+    secrets?: Capability;
+    /** Alarms / scheduled wakeup inside a shard. */
+    shardAlarms?: Capability;
+    /** Durable Object-style sharded state. */
+    shardedState?: Capability;
+    /** Vector database (Vectorize / pgvector / Pinecone). */
+    vectorStore?: Capability;
+    /** Hibernated WebSocket subscriptions. */
+    websocketHibernation?: Capability;
+    /** Durable workflows (step-based). */
+    workflows?: Capability;
+  };
+  /** Platform identifier used in codegen and config (e.g. "cloudflare", "aws"). */
+  id: string;
+  /** Human-readable platform name (e.g. "Cloudflare", "AWS", "Rivet"). */
+  name: string;
+}
+/**
+ * The Cloudflare capability matrix — the reference implementation.
+ *
+ * `native` means the platform itself provides the feature; `emulated` means
+ * Lunora builds it on top of lower-level platform primitives (or a third-party
+ * service) rather than consuming a first-class product. Codegen and Studio read
+ * this distinction to report parity honestly, so a feature Lunora implements
+ * itself must not be reported as native even when it works flawlessly.
+ */
+declare const CLOUDFLARE_CAPABILITIES: PlatformCapabilities;
+/**
+ * The Node capability matrix — `@lunora/platform-node`'s honest self-rating
+ * (plan 234).
+ *
+ * `@lunora/platform-node` is a spike: a `ShardHost`/`SocketHost`/
+ * `ShardDirectory`/`ShardKvStore`/`SchedulerHost` implementation over
+ * `better-sqlite3` and an in-process registry, built to run the conformance
+ * TCK against a second host and discover what the contracts under-specify.
+ * It is a single Node process with no distributed placement, no host-level
+ * scheduler to re-arm timers after a restart, and no bindings at all for the
+ * Cloudflare-specific products (R2, Vectorize, Workers AI, Queues,
+ * Workflows, Containers, Browser Rendering, Analytics Engine, Secrets Store,
+ * Hyperdrive) most `ctx.*` surfaces are built on. Every one of those is
+ * rated `"unsupported"` here rather than left undeclared — see
+ * `gateAgainstMatrix` in `@lunora/codegen`, whose fail-closed gate (plan
+ * 229) treats an undeclared feature as unsupported anyway, but under a
+ * different diagnostic name than an honest, explicit rating.
+ *
+ * Two features are rated `"emulated"` rather than `"native"` even though
+ * this package fully implements their contract, because "native" would
+ * overstate what a bare Node process provides on its own: `keyValueStore` is
+ * a SQL table wearing a KV-shaped API, not a dedicated KV product, and
+ * `websocketHibernation` never actually evicts a socket to save memory — it
+ * only proves the attachment/tag durability half of the contract, not real
+ * hibernation. Both ratings, and the `"unsupported"` ones for `scheduler`
+ * durability and `globalTables`, are argued in detail in
+ * `plans/234-node-host-findings.md`.
+ */
+declare const NODE_CAPABILITIES: PlatformCapabilities;
+export { type AnalyticsEngineDataPoint, type AnalyticsEngineDataPointLike, type AnalyticsEngineDatasetLike, CLOUDFLARE_CAPABILITIES, type Capability, type CapabilityLevel, type D1DatabaseLike, type D1PreparedStatementLike, type D1SessionLike, type ExecutionContextLike, type KVNamespaceLike, type KvGetOptions, type KvListKey, type KvNamespaceListResult, type KvNamespacePutOptions, type KvValue, type KvValueType, type MessageBatchLike, type MessageLike, type MessageSendRequestLike, NODE_CAPABILITIES, NOOP_EXECUTION_CONTEXT, type PlatformCapabilities, type QueueBindingLike, type QueueContentType, type QueueMessageLike, type QueueRetryOptions, type QueueSendBatchOptions, type QueueSendOptions, type QueueSendOptionsLike, type QueueSendRequestLike, type R2BucketLike, type R2MultipartUploadLike, type R2ObjectBodyLike, type R2ObjectLike, type R2RangeLike, type R2UploadedPartLike, type VectorMatchLike, type VectorMetric, type VectorRecordLike, type VectorizeDeleteMutation, type VectorizeIndexDetails, type VectorizeIndexLike, type VectorizeMatch, type VectorizeMatches, type VectorizeQueryOptions, type VectorizeUpsertMutation, type VectorizeVector };

package/dist/index.mjs ADDED Viewed

	@@ -0,0 +1 @@
1	+ import{NOOP_EXECUTION_CONTEXT as E}from"./packem_shared/NOOP_EXECUTION_CONTEXT-YmXqH-jH.mjs";import{CLOUDFLARE_CAPABILITIES as O,NODE_CAPABILITIES as e}from"./packem_shared/CLOUDFLARE_CAPABILITIES-CfXSyHOn.mjs";import{resolveShard as C}from"./packem_shared/resolveShard-uGhAKuTB.mjs";export{O as CLOUDFLARE_CAPABILITIES,e as NODE_CAPABILITIES,E as NOOP_EXECUTION_CONTEXT,C as resolveShard};

package/dist/packem_shared/CLOUDFLARE_CAPABILITIES-CfXSyHOn.mjs ADDED Viewed

@@ -0,0 +1 @@

+ const e={id:"cloudflare",name:"Cloudflare",features:{shardedState:{level:"native",note:"Durable Objects with SQLite"},globalTables:{level:"native",note:"D1 with Sessions API"},websocketHibernation:{level:"native",note:"DO WebSocket hibernation"},localSql:{level:"native",note:"state.storage.sql (SQLite)"},shardAlarms:{level:"native",note:"state.storage.setAlarm"},crossShardFanout:{level:"emulated",note:"Lunora query coordinator + relay tier over Durable Objects"},queues:{level:"native",note:"Cloudflare Queues"},workflows:{level:"native",note:"Cloudflare Workflows"},scheduler:{level:"emulated",note:"SchedulerDO (Lunora, on DO alarms) + declarative Cron Triggers; no runtime cron registration"},objectStorage:{level:"native",note:"R2"},keyValueStore:{level:"native",note:"Workers KV"},vectorStore:{level:"native",note:"Vectorize"},ai:{level:"native",note:"Workers AI"},browser:{level:"native",note:"Browser Rendering"},containers:{level:"native",note:"Cloudflare Containers"},analytics:{level:"native",note:"Analytics Engine"},pipelines:{level:"native",note:"Cloudflare Pipelines"},mail:{level:"emulated",note:"Resend (third-party) via Cloudflare Queues"},secrets:{level:"native",note:"Secrets Store"},hyperdrive:{level:"native",note:"Cloudflare Hyperdrive"}}},t={id:"node",name:"Node",features:{shardedState:{level:"emulated",note:"One better-sqlite3 database per shard key, one process — no distributed placement or failover"},globalTables:{level:"unsupported",note:"No replicated SQL store (D1-equivalent) implemented"},websocketHibernation:{level:"emulated",note:"In-process socket registry; attachments/tags survive a simulated recycle, not a process restart, and nothing is ever actually evicted from memory"},localSql:{level:"native",note:"better-sqlite3 (synchronous, embedded)"},shardAlarms:{level:"emulated",note:"In-process setTimeout; the timestamp can be persisted to SQLite but nothing re-arms it on process restart"},crossShardFanout:{level:"unsupported",note:"No query coordinator / relay tier implemented"},queues:{level:"unsupported",note:"No Cloudflare Queues equivalent implemented"},workflows:{level:"unsupported",note:"No Cloudflare Workflows equivalent implemented"},scheduler:{level:"emulated",note:"In-process setTimeout only; not durable across a process restart, and no dynamic cron registration is implemented"},objectStorage:{level:"unsupported",note:"No R2/S3-equivalent binding implemented"},keyValueStore:{level:"emulated",note:"better-sqlite3 table behind the ShardKvStore API — not a dedicated KV product"},vectorStore:{level:"unsupported",note:"No Vectorize-equivalent binding implemented"},ai:{level:"unsupported",note:"No Workers AI-equivalent binding implemented"},browser:{level:"unsupported",note:"No headless-browser binding implemented"},containers:{level:"unsupported",note:"No container orchestration implemented"},analytics:{level:"unsupported",note:"No Analytics Engine-equivalent binding implemented"},pipelines:{level:"unsupported",note:"No Pipelines-equivalent binding implemented"},mail:{level:"unsupported",note:"@lunora/mail's queue-backed sends need a queues binding, which this target does not provide"},secrets:{level:"unsupported",note:"No Secrets Store-equivalent binding implemented (a real host would likely map this to env vars)"},hyperdrive:{level:"unsupported",note:"No connection-pooling binding implemented"}}};export{e as CLOUDFLARE_CAPABILITIES,t as NODE_CAPABILITIES};

package/dist/packem_shared/NOOP_EXECUTION_CONTEXT-YmXqH-jH.mjs ADDED Viewed

	@@ -0,0 +1 @@
1	+ const t={passThroughOnException:()=>{},waitUntil:()=>{}};export{t as NOOP_EXECUTION_CONTEXT};

package/dist/packem_shared/createReferenceHost-GO8Hp4ft.mjs ADDED Viewed

@@ -0,0 +1 @@

+ import{DatabaseSync as k}from"node:sqlite";let w=0,v=0;const B=()=>(w+=1,`socket-${w}`),D=()=>(v+=1,`job-${v}`),L=n=>n===void 0?null:n,C=n=>typeof n=="string"?new TextEncoder().encode(n).buffer:n instanceof ArrayBuffer?n:ArrayBuffer.isView(n)?n.buffer.slice(n.byteOffset,n.byteOffset+n.byteLength):new ArrayBuffer(0),R=()=>{const n=new k(":memory:"),s={alarmAt:null,alarmTimeout:null,pending:[],running:!1},i=new Map,f=new Map,u=new Map,T={exec:(e,...t)=>{const r=n.prepare(e),a=t.map(L),o=e.trim().toLowerCase().startsWith("select")?r.all(...a):(r.run(...a),[]);return{[Symbol.iterator]:()=>o[Symbol.iterator](),one:()=>{if(o.length!==1)throw new Error(`expected exactly one row, got ${String(o.length)}`);return o[0]},toArray:()=>[...o]}}},A={all:async(e,t)=>n.prepare(e).all(...t),run:async(e,t)=>{const r=n.prepare(e).run(...t);return{rowsAffected:Number(r.changes)}}},g=()=>{if(s.running||s.pending.length===0)return;const e=s.pending.shift();e!==void 0&&(s.running=!0,e.function_().then(e.resolve,e.reject).finally(()=>{s.running=!1,g()}))},b={alarms:{delete:()=>{s.alarmAt=null,s.alarmTimeout!==null&&(clearTimeout(s.alarmTimeout),s.alarmTimeout=null)},get:()=>s.alarmAt,set:e=>{const t=typeof e=="number"?e:e.getTime();s.alarmAt=t,s.alarmTimeout!==null&&clearTimeout(s.alarmTimeout);const r=Math.max(0,t-Date.now());s.alarmTimeout=setTimeout(()=>{s.alarmAt=null,s.alarmTimeout=null},r)}},asyncSql:A,runSerialized:e=>new Promise((t,r)=>{s.pending.push({function_:e,reject:a=>{r(a)},resolve:a=>{t(a)}}),g()}),sql:T,transaction:async e=>{n.exec("BEGIN");try{const t=await e();return n.exec("COMMIT"),t}catch(t){throw n.exec("ROLLBACK"),t}},waitUntil:()=>{}},c=new WeakMap,h=e=>{const t={bufferedAmount:e.bufferedAmount,close:(r,a)=>{e.closed=!0},deserializeAttachment:()=>e.attachment,send:r=>{e.received.push(typeof r=="string"?r:C(r))},serializeAttachment:r=>{e.attachment=r,f.set(e.id,r)}};return e.handle=t,c.set(t,e.id),t},M={accept:(e,t,r)=>{const a=B(),o={attachment:t,bufferedAmount:0,closed:!1,raw:e,handle:null,id:a,received:[],tags:new Set(r)};return i.set(a,o),u.set(a,new Set(r)),t!==void 0&&f.set(a,t),h(o)},getSockets:e=>{const t=[...i.values()];return(e===void 0?t:t.filter(r=>r.tags.has(e))).map(r=>r.handle)},handleFor:e=>[...i.values()].find(t=>t.raw===e)?.handle,idFor:e=>{const t=c.get(e);if(t===void 0)throw new Error("reference host: idFor called with a handle this host never issued");return t},removeTag:(e,t)=>{const r=i.get(c.get(e)??"");r!==void 0&&(t===void 0?r.tags.clear():r.tags.delete(t),u.set(c.get(e)??"",new Set(r.tags)))},setTag:(e,t)=>{const r=c.get(e)??"",a=i.get(r);a!==void 0&&(a.tags.add(t),u.set(r,new Set(a.tags)))}},p={get:e=>({fetch:async()=>new Response(String(e))}),getByName:e=>({fetch:async()=>new Response(e)}),idForName:e=>`shard:${e}`,jurisdiction:e=>p},d=new Map,S={delete:async e=>d.delete(e),get:async e=>d.get(e),list:async e=>{const t=e?.prefix??"",r=new Map;for(const[a,o]of d)a.startsWith(t)&&r.set(a,o);return r},put:async(e,t)=>{d.set(e,structuredClone(t))}},l=new Map,m=new Map,y=(e,t)=>({attempts:t.attempts,functionPath:t.functionPath,id:e,scheduledFor:t.scheduledFor});return{awaitAlarmFired:async e=>{await new Promise(t=>{setTimeout(t,Math.max(0,e-Date.now())+30)})},cleanup:()=>{n.close(),s.alarmTimeout!==null&&clearTimeout(s.alarmTimeout);for(const e of l.values())clearTimeout(e.timer)},directory:p,kv:S,readFrames:e=>(i.get(c.get(e)??"")?.received??[]).filter(t=>typeof t=="string"),restoreSocket:(e,t)=>{const r={attachment:t,bufferedAmount:0,closed:!1,handle:null,id:e,raw:void 0,received:[],tags:new Set(u.get(e))};return i.set(e,r),h(r)},scheduler:{cancel:async e=>{const t=l.get(e);return t===void 0?!1:(clearTimeout(t.timer),l.delete(e),!0)},cron:async()=>{},deadLetter:{list:async()=>[...m].map(([e,t])=>y(e,t)),requeue:async e=>{const t=m.get(e);return t===void 0?!1:(m.delete(e),l.set(e,{...t,attempts:0,timer:void 0}),!0)}},list:async()=>[...l].map(([e,t])=>y(e,t)),schedule:async(e,t,r)=>{const a=D();let o;r?.at===void 0?o=Date.now()+(r?.delayMs??0):o=typeof r.at=="number"?r.at:r.at.getTime();const x=Math.max(0,o-Date.now()),F=setTimeout(()=>{l.delete(a)},x);return l.set(a,{args:t,attempts:0,functionPath:e,options:r??{},scheduledFor:o,timer:F}),{id:a,scheduledFor:o}}},simulateDeadLetter:async e=>{const t=l.get(e);return t===void 0?!1:(clearTimeout(t.timer),l.delete(e),m.set(e,{...t,attempts:(t.options.retry?.maxAttempts??5)+1,timer:void 0}),!0)},shard:b,simulateRecycle:()=>{i.clear()},socket:M}};export{R as createReferenceHost};

package/dist/packem_shared/resolveShard-uGhAKuTB.mjs ADDED Viewed

	@@ -0,0 +1 @@
1	+ const t=(e,o)=>e.getByName!==void 0?e.getByName(o):e.get(e.idForName(o));export{t as resolveShard};