Skip to content
Cello
Esc
↑↓navigate↵open⌘Jpreview
On this page

Cloudflare compatibility

This page lists only the differences from the linked Cloudflare APIs. An entry without a note matches Cloudflare.

  • Yes: implemented, except for the listed differences.
  • Partial: a substantial part is unavailable.
  • Experimental: can change without notice.
  • No: not implemented.

Cello rejects an unsupported configuration or API at deployment or first use. An unsupported feature that does not cause an error is a defect.

Services

service status
Workers Yes
Durable Objects Yes
Durable Object Facets Yes
Containers Experimental
Static assets Yes
Cron Triggers Yes
Dynamic Workers Yes
KV Yes
Queues Yes
D1 Yes
Workflows Yes
R2 Yes
Workers AI No
Vectorize No
Hyperdrive No
Browser Rendering No
Email Workers No
Python Workers Partial — fetch handlers on the Pyodide 0.28 runtime line

Runtime APIs

API status
Fetch, Request, Response, and Headers Yes
Bindings Yes
Context Yes
Handlers Yes
RPC Yes
Streams Yes
Encoding Yes
WebSockets Yes
Web Crypto Yes
Web standards Yes
WebAssembly Yes
Performance and timers Yes
Console Yes
Node.js compatibility Partial
Cache Yes
HTMLRewriter Yes
TCP sockets Yes
EventSource Yes
MessageChannel Yes
BroadcastChannel No

Fetch, Request, Response, and Headers

  • The cache request option is unavailable.
  • A gzip or deflate response body decodes before delivery, unless the request names accept-encoding (then the body arrives raw, as the Fetch standard requires). content-encoding stays on the response, as in workerd; the wire size no longer describes the body, so content-length is removed.
  • An inbound Request has a cf object without Cloudflare edge fields. Cello cannot prove the geolocation, colo, or TLS metadata.
  • Cello removes Content-Length from a Worker response, except for a HEAD response.
  • A cloned body that the platform streams (a fetch(), RPC, Durable Object or R2 body) applies backpressure at the slower copy: reading only one copy stalls it after 16 chunks until the other copy is read, cancelled, or expires. Workerd buffers for the slower copy instead.
  • A remote Durable Object call cannot retry after request-body transmission starts because Cello keeps no replay copy.
  • A remote Durable Object call waits for a rejected owner generation to change for at most CELLO_OPERATION_DEADLINE_MS.

Bindings

Only the binding types in the services table are available.

env additionally carries CELLO_NODE: the name of the node running the code, injected by the host after every deployment binding. A bundle that must refuse a credential minted for another region reads this, not placement. No deployment may bind the name — vars, .dev.vars, and every other binding kind are refused at deploy time — and a loaded Worker’s props cannot smuggle it past the host value of an isolate that has one.

In a Worker Loader bundle (env.LOADER), a cloudflare:workers name imported only by a non-entry chunk still resolves: external stubs cover the union of the main module’s and every sibling’s imports.

Context

  • passThroughOnException() has no effect because Cello has no CDN fallback.
  • ctx.facets is available only inside a Durable Object.

Handlers

The tail and email handlers are unavailable.

RPC

  • Durable Object RPC stubs cross isolate boundaries on the same node: a method called on a stub returned by another isolate runs against the owning cell. A stub whose owner runs on another node rejects with a clear error (no cross-node forwarding yet); a stub whose owner was evicted or reloaded rejects like a released same-isolate stub. Old-shape markers (no host id) keep failing on use exactly as before.
  • A stub received by a caller is owned by the caller’s request: when the fetch/RPC/alarm/queue invocation ends, every stub it still holds is disposed and every release routes to the owner. There is no idle expiry: a quiet-but-live handle stays usable however long nothing flows, and a validated operation pins its entry so a release racing it cannot fail it. Owner eviction revokes synchronously, and isolate retirement releases whatever the freed isolate still held.
  • A stream received over RPC stays usable while the receiver holds it: an active reader (or writer) keeps the stream past the receiving call and its invocation, the way a ReadableStream sent over RPC stays open until its writer closes it. Reading to the end, closing, cancelling, or an explicit dispose releases the hold at once; a dropped stream frees when collected, or when its isolate retires.
  • A caller-owned ReadableStream passed in call arguments crosses to the cell through an upload channel: the caller’s isolate pumps it host-side (bounded, backpressured) and the cell pulls. Cancellation propagates both ways, and the channel dies with the sender’s invocation. A caller-owned WritableStream has no reverse path: it keeps a same-isolate marker and fails on use across isolates.
  • Minting is capped per scope (4096 live stubs) and per process (65536 stubs, 8192 uploads), failing the call with a clear error past the cap. CELLO_STUB_SCOPE_CAP, CELLO_STUB_PROCESS_CAP, and CELLO_UPLOAD_CAP override the caps. Stub ids are 128-bit bearer tokens bound to the isolate that revived them; a stolen id alone is useless, and ids never log or serialize observably. Upload ids are process-wide bearer tokens without holder binding (any isolate presenting one can pull, push, or cancel it), contained by the same unguessability, uniform errors, and non-observability: markers never surface to script, and forwarding moves the wrapper rather than the id. One Cello process is one fleet, so the bearer boundary is the process.
  • An AbortSignal in a Durable Object RPC call crosses on the same node (live: the receiver observes an abort the sender fires later) but does not cross a node boundary. Cancelling publishes synchronously, so the abort reaches the callee even as the caller’s entry retires.
  • A remote RPC retries only when the failed peer attempt did not start the method. Use a stable operation ID for an application retry.
  • A plain object or array returned over RPC carries a no-op Symbol.dispose, so a using declaration typechecks; only results that revive stubs or disposers release anything.
  • Deviations from workerd stub lifetime: a stub used only from waitUntil work after the handler settles is already disposed; a stub a Durable Object stores on its instance does not survive into a later invocation; a stub does not survive a socket upgrade. Each fails closed with a disposed error instead of leaking.
  • globalThis.__celloStubStatsForTestOnly() reports this isolate’s stub counts for the conformance suite. It exists only on nodes booted with CELLO_TEST_STUB_STATS=1 (a process environment variable, which tenant code cannot set); production isolates never define it. It is test tooling, not a runtime API.

Streams

  • Cello expires an unclaimed and inactive HTTP stream after 60 seconds. A successful stream operation starts a new 60-second period.
  • An expired or unknown stream reports an error instead of EOF.
  • Byte streams cross isolate boundaries on the same node as part of Durable Object RPC, in both directions: a ReadableStream returned by a cell reads chunk by chunk, and a WritableStream it returns accepts writes, closes, and aborts. A ReadableStream passed in call arguments crosses the other way, pumped caller-side through a bounded host channel the cell pulls (see RPC above). Only byte chunks cross that channel: a non-bytes chunk fails the stream with a disconnect rather than mangling it. Nothing here expires on a timer.

WebSockets

  • An outbound Worker socket closes when its event and waitUntil work end. A socket returned in the response stays open.
  • Each isolate-polled input queue has a 1 MiB budget for non-terminal frames. A message larger than 1 MiB uses the complete budget.
  • If the isolate stops polling, Cello discards unread frames during cleanup. A later pull reports an abnormal close.
  • A WebSocket transport cannot move to a new cell owner. A client must reconnect with the same application operation ID.
  • A tunneled connection forwards the owner’s Close without an additional Close. If the owner connection fails between frames before a Close, the ingress sends code 1012. If a frame is incomplete, the ingress closes the transport instead.
  • acceptWebSocket() throws above 90 percent of the V8 heap limit.
  • A response with a WebSocket to a request without Upgrade: websocket fails, as in workerd. A Durable Object’s stub.fetch() call then rejects, and an HTTP client receives status 500. The server end of the socket receives a close event with code 1006.
  • A Durable Object’s stub.fetch() call rejects when the handler fails, on the owner node and on any other node.
  • A Worker Loader worker (env.LOADER) answers a WebSocket upgrade the same way: a 101 response carrying webSocket routes to its target whether the loaded worker made the socket itself or forwards the upgrade to a Durable Object.
  • close() sends 1000–4999 except the reserved no-status codes 1004, 1005, 1006, and 1015, which stay refused. Codes 1001–1014 that the old WHATWG-only rule rejected now close, so a 1008 policy-violation refusal reaches the peer instead of throwing.
  • A Durable Object can open an outbound WebSocket after it answers: the dial routes by the object’s cell, not by the dead request.

Web Crypto

  • HMAC accepts MD5, SHA-1, SHA-224, SHA-256, SHA-384, and SHA-512.
  • ECDSA supports only the P-256 curve with SHA-256.
  • AES-GCM accepts authentication tags from 96 through 128 bits in 8-bit steps.
  • RSA-OAEP accepts SHA-1, SHA-256, SHA-384, and SHA-512. A nonempty label must contain valid UTF-8.
  • AES-KW wraps and unwraps (RFC 3394; an IV mismatch fails the unwrap). A symmetric key imports and exports as raw bytes and as jwk with kty: "oct".
  • Ed25519 signs and verifies, and NODE-ED25519 names the same algorithm. A signature from one spelling verifies under the other.
  • X25519 derives bits and keys. A peer key of a low order gives a shared secret of all zero bytes, so deriveBits() rejects that key instead.
  • An Ed25519 or X25519 public key uses its 32-byte point for the raw format, so importKey() and exportKey() both carry the point alone.
  • An EC public key imports and exports the uncompressed point as raw.

Web standards

AbortSignal.timeout() never keeps its event (or its admission slot) alive: the timer is unreferenced, so it fires or dies with the request, whichever comes first, and carries no timer id or cancellation.

Performance and timers

performance.timeOrigin is 0, and performance.now() matches Date.now(). Both clocks advance at an I/O boundary and stay fixed during JavaScript execution.

Node.js compatibility

  • Cello implements node:assert, node:async_hooks, node:buffer, node:diagnostics_channel, node:events, node:fs, node:os, node:path, node:stream, node:timers/promises, and node:util.
  • node:diagnostics_channel does not export messages to a tail Worker.
  • node:crypto does not implement Diffie-Hellman, streaming signatures, ciphers, RSA-PSS, or DSA signatures and key generation.
  • node:crypto implements scrypt/scryptSync with Node’s parameters and defaults (N/cost 16384, r/blockSize 8, p/parallelization 1, maxmem 32 MiB).
  • KeyObject.toCryptoKey() applies the requested algorithm, extractability, and usages to an asymmetric key.
  • node:zlib implements only the synchronous gzip and deflate functions.
  • node:fs provides access, mkdir, realpath, stat, lstat, readFile, writeFile, writeFileSync, appendFile, appendFileSync (plus fs.promises), and read/write streams. /tmp is writable and request-local: writeFile truncates unless { flag: "a" } appends, createWriteStream writes chunks as they arrive, and anything that would push a request past CELLO_TMP_MAX_BYTES (default 64 MiB) fails with ENOSPC, while an overwrite frees the replaced bytes. /bundle is read-only and contains the Worker modules.
  • node:url provides pathToFileURL/fileURLToPath plus the WHATWG URL API, with POSIX path rules only.
  • The global process matches workerd for each field that it defines, such as process.execPath, process.argv, and process.title. Other fields, such as process.kill and process.features, are undefined.
  • The Cello bundler supports a synchronous CommonJS require() of a Node.js built-in module. A raw ESM Worker has no global require().
  • A Node.js built-in module object is writable, so a dependency such as graceful-fs can patch it at load. The patch stays in its isolate.
  • An import of another Node.js module succeeds, but its first call throws an error.

Cache

See Cache for the full behavior, freshness rules, and limits.

  • The cache is per-node and in-memory: entries survive across isolates of one script on one node, never cross scripts, and never cross nodes.
  • fetch() neither reads nor populates the cache, and cf.cacheKey is unsupported; the request URL is the whole key.
  • No API purges by Cache-Tag; purge by URL with delete.

TCP sockets

  • A socket cannot outlive its event. A Durable Object must reconnect during a later event.
  • Cello verifies a TLS server against its bundled Mozilla root store.
  • Cello does not block the destination ports that Cloudflare blocks. The fleet network controls the egress policy.

BroadcastChannel

The class exists so that a bundle can load, but its constructor throws.

Compatibility flags

Cello honors these compatibility flags:

  • delete_all_deletes_alarm
  • js_rpc
  • fetcher_no_get_put_delete
  • sqlite_vec
  • websocket_standard_binary_type
  • The static-assets navigation flags

Cello accepts every other flag without effect. Cloudflare.compatibilityFlags reports only the honored flags.

Wrangler configuration

cello deploy accepts wrangler.jsonc or wrangler.json, not wrangler.toml.

The name value must contain 1 to 63 lowercase ASCII letters, digits, or internal hyphens. It cannot start or end with a hyphen.

The accepted top-level keys:

  • $schema, name, main, and no_bundle
  • compatibility_date and compatibility_flags
  • durable_objects and migrations
  • assets, services, triggers, and vars
  • d1_databases, kv_namespaces, queues, workflows, and r2_buckets
  • worker_loaders and containers
  • define and rules

Any other top-level key, including routes, stops the deployment.

define and rules go to the esbuild run. Each define value is a JavaScript expression, as in Wrangler. A rule type must be Text, Data, or CompiledWasm, and each glob must have the form **/*.ext or *.ext, because esbuild selects a loader by extension. Two rules that give one extension different types stop the deployment. Cello already applies CompiledWasm to **/*.wasm, so only that type is valid for .wasm. no_bundle skips esbuild, so no_bundle with define or rules stops the deployment.

An asset-only project can omit main. cello deploy refuses an unsafe asset path, and .assetsignore requires Wrangler.

See Limitations for the operational limits.

Was this page helpful?