js-valkey-server 0.3.0

package/dist/index.d.mts

@@ -0,0 +1,502 @@
+import { R as RedisCluster, a as RedisServerState, C as CompatibilitySpec, L as Logger, b as RedisClusterNodeHandle, c as Resp2Server, d as CommandExecutor, e as RedisValue } from './redis-error-C96iHLJ-.mjs';
+export { f as CompatibilityProfile, g as CountGreaterThanZeroError, D as DiscardWithoutMultiError, E as ExecWithoutMultiError, h as ExpectedFloatError, i as ExpectedIntegerError, F as FeatureId, H as HashValueNotFloatError, j as HashValueNotIntegerError, I as IndexOutOfRangeError, k as InvalidExpireTimeError, l as LimitCantBeNegativeError, M as MinMaxNotFloatError, N as NoAuthError, m as NoPasswordConfiguredError, n as NoScriptError, o as NoSuchKeyError, p as NumKeysGreaterThanZeroError, O as OffsetOutOfRangeError, P as PositiveCountError, q as RedisClusterDownError, r as RedisClusterOptions, s as RedisCommandError, t as RedisCrossSlotError, u as RedisFlavor, v as RedisMovedError, w as RedisSyntaxError, x as ResultingScoreNaNError, S as ScriptCallNoCommandError, y as ScriptDebugModeError, z as ScriptFlushOptionError, A as ScriptUnknownCommandError, B as StreamElementTooLargeError, G as StreamIdExhaustedError, T as TransactionDiscardedError, U as UnknownClusterSubcommandError, J as UnknownRedisCommandError, K as UnknownScriptSubcommandError, V as VersionGate, W as WatchInsideMultiError, Q as WrongNumberOfArgumentsError, X as WrongNumberOfKeysError, Y as WrongPassError, Z as WrongTypeRedisError, _ as ZaddGtLtNxConflictError, $ as ZaddIncrPairError, a0 as ZaddNxXxConflictError, a1 as buildRedisCluster, a2 as computeSlotRange, a3 as createRedisCluster, a4 as gateSatisfied, a5 as resolveCompatibilityProfile } from './redis-error-C96iHLJ-.mjs';
+import { Redis, Cluster } from 'ioredis';
+import 'net';
+import 'lua-redis-wasm';
+
+/**
+ * Public seeding contract for {@link RedisMock}. Callers describe data with
+ * plain keys/types/values (plus optional `ttlMs` and `db`); the mock owns the
+ * conversion into the internal {@link RedisDataValue} representation and the
+ * placement onto the right database (and, in cluster mode, the right node).
+ *
+ * Streams are intentionally not seedable yet — their public entry shape (entry
+ * ids, fields, consumer groups) is not finalized, and exposing the internal
+ * stream state would leak implementation details.
+ */
+type SeedEntry = {
+    key: string;
+    type: 'string';
+    value: string | number;
+    ttlMs?: number;
+    db?: number;
+} | {
+    key: string;
+    type: 'hash';
+    value: Record<string, string | number>;
+    ttlMs?: number;
+    db?: number;
+} | {
+    key: string;
+    type: 'list';
+    value: (string | number)[];
+    ttlMs?: number;
+    db?: number;
+} | {
+    key: string;
+    type: 'set';
+    value: (string | number)[];
+    ttlMs?: number;
+    db?: number;
+} | {
+    key: string;
+    type: 'zset';
+    value: Record<string, number>;
+    ttlMs?: number;
+    db?: number;
+};
+declare function seedStandalone(state: RedisServerState, entries: readonly SeedEntry[]): Promise<void>;
+/**
+ * The minimal cluster shape `seedCluster` needs: a topology to slot keys and the
+ * per-node `RedisServerState` to write into. Both the socket-backed
+ * {@link RedisCluster} (`.nodes[].server`) and the TCP-free `buildClusterNodes`
+ * product satisfy this structurally, so the in-memory ioredis mock can reuse the
+ * same seeder.
+ */
+type SeedClusterTarget = {
+    topology: RedisCluster['topology'];
+    nodes: readonly {
+        id: string;
+        server: RedisServerState;
+    }[];
+};
+declare function seedCluster(cluster: SeedClusterTarget, entries: readonly SeedEntry[]): Promise<void>;
+
+type RedisAddress = {
+    host: string;
+    port: number;
+};
+type CreateRedisServerOptions = {
+    /** Port to bind. Defaults to `0` (OS-assigned free port). */
+    port?: number;
+    /** Logical database count. Defaults to 16, matching real Redis. */
+    databaseCount?: number;
+    compatibility?: CompatibilitySpec;
+    logger?: Pick<Logger, 'error'>;
+};
+type CreateRedisServerClusterOptions = {
+    /** Build a (listening) cluster instead of a standalone server. */
+    cluster: RedisMockClusterOptions;
+    /** Cluster base port. Defaults to `0` (each node OS-assigned). */
+    basePort?: number;
+    /** Databases per cluster node. Defaults to 1. */
+    databasesPerNode?: number;
+    compatibility?: CompatibilitySpec;
+    logger?: Pick<Logger, 'error'>;
+};
+type RedisServerHandle = {
+    host: string;
+    port: number;
+    state: RedisServerState;
+    server: Resp2Server;
+    close(): Promise<void>;
+};
+/**
+ * Runs a real, **listening** Redis server you connect a normal client library
+ * to. Standalone by default (one {@link RedisServerState} + executor +
+ * {@link Resp2Server}, 16 databases); pass `cluster` to build and start a whole
+ * cluster instead — the returned {@link RedisCluster} is already listening.
+ *
+ * For tests prefer {@link createRedisMock}, which wraps this and adds seeding,
+ * reset-between-tests, and an in-process socketless client. Drop to
+ * `js-redis-server/core` only when you need to assemble the pipeline by hand.
+ *
+ * @see {@link createRedisMock} — the test-mock facade (use this for test suites)
+ */
+declare function createRedisServer(options?: CreateRedisServerOptions): Promise<RedisServerHandle>;
+declare function createRedisServer(options: CreateRedisServerClusterOptions): Promise<RedisCluster>;
+type RedisMockClusterOptions = {
+    masters: number;
+    replicas?: number;
+};
+type CreateRedisMockOptions = {
+    /** When set, builds a cluster mock instead of a standalone one. */
+    cluster?: RedisMockClusterOptions;
+    /** Standalone-only: logical database count (defaults to 16). */
+    databaseCount?: number;
+    /** Standalone bind port. Defaults to `0` (OS-assigned). */
+    port?: number;
+    /** Cluster base port. Defaults to `0` (each node OS-assigned). */
+    basePort?: number;
+    compatibility?: CompatibilitySpec;
+    logger?: Pick<Logger, 'error'>;
+};
+/**
+ * Friendly test-mock facade over a standalone server or a cluster. Exposes
+ * connection helpers, seeding, reset-between-tests, and escape hatches to the
+ * underlying state/nodes for power users.
+ *
+ * Need a socketless in-process client (no TCP, no RESP)? Use the standalone
+ * {@link createInMemoryClient} builder instead.
+ */
+interface RedisMock {
+    readonly host: string;
+    readonly port: number;
+    readonly url: string;
+    /**
+     * Node addresses as `{ host, port }[]` — a single entry for standalone mocks,
+     * every node for cluster mocks. Client-agnostic: index `[0]` for a single
+     * client, or pass the whole array to a cluster client.
+     *
+     * @example new Redis(mock.addresses()[0])         // ioredis, standalone
+     * @example new Redis.Cluster(mock.addresses())    // ioredis, cluster
+     */
+    addresses(): RedisAddress[];
+    seed(entries: readonly SeedEntry[]): Promise<void>;
+    flush(): Promise<void>;
+    /** Alias for {@link RedisMock.flush}. */
+    reset(): Promise<void>;
+    close(): Promise<void>;
+    /** Escape hatch: the underlying state (standalone mocks only). */
+    readonly state?: RedisServerState;
+    /** Escape hatch: the underlying node handles (cluster mocks only). */
+    readonly nodes?: readonly RedisClusterNodeHandle[];
+}
+/**
+ * Creates a {@link RedisMock} — the entry point for test suites. Standalone by
+ * default; pass `{ cluster: { masters } }` for a cluster mock. Adds seeding and
+ * reset-between-tests on top of a real server/cluster.
+ *
+ * To run a long-running server a separate process connects to (a CLI, a dev
+ * tool) rather than drive it from test code, use {@link createRedisServer}
+ * instead (it takes the same `cluster` option).
+ *
+ * @see {@link createRedisServer} — run a real server/cluster without test helpers
+ */
+declare function createRedisMock(options?: CreateRedisMockOptions): Promise<RedisMock>;
+/** Alternative name for the same factory; compatibility defaults are unchanged. */
+declare const createValkeyMock: typeof createRedisMock;
+
+type CreateIoredisMockOptions = {
+    cluster?: false;
+    databaseCount?: number;
+    seed?: readonly SeedEntry[];
+} | {
+    cluster: {
+        masters: number;
+        replicasPerMaster?: number;
+    };
+    seed?: readonly SeedEntry[];
+};
+/**
+ * A drop-in, socketless `ioredis` client (standalone or `Cluster`) backed by the
+ * in-memory server pipeline. The **real** ioredis client drives a fake
+ * `net.Socket` ({@link createVirtualConnection}) over real RESP, so reply
+ * shaping, pipelines, `multi`, pub/sub, and `scanStream` all work for free — no
+ * TCP socket and no port bind.
+ *
+ * `ioredis` is an optional peer dependency, imported lazily, so the core stays
+ * dependency-free.
+ */
+declare function createIoredisMock(options?: CreateIoredisMockOptions): Promise<Redis | Cluster>;
+
+/** A command argument the in-memory client accepts. */
+type RedisCommandArgument = string | number | Buffer;
+/** Native JS value an in-memory reply decodes to. */
+type RedisNativeReply = string | number | bigint | boolean | Buffer | null | RedisNativeReply[] | {
+    [key: string]: RedisNativeReply;
+};
+type InMemoryRedisClientOptions = {
+    server: RedisServerState;
+    executor: CommandExecutor;
+    /** Initial selected database (default 0). */
+    database?: number;
+    /** Return `Buffer`s for bulk-string/verbatim replies instead of utf8 strings. */
+    returnBuffers?: boolean;
+    /** Called once when the client is closed — used to tear down owned state. */
+    onClose?: () => void;
+};
+/**
+ * Socketless, high-level client that drives the **same** command pipeline as a
+ * networked client through an in-process {@link ClientSession} — bypassing both
+ * the TCP loopback and RESP encoding/decoding. Intended for tests that just need
+ * to issue commands and read native JS replies without pulling in a real client
+ * library.
+ *
+ * Streaming commands (SUBSCRIBE / PSUBSCRIBE / MONITOR) are not supported here;
+ * use a real client for those.
+ */
+declare class InMemoryRedisClient {
+    private readonly session;
+    private readonly returnBuffers;
+    private readonly onClose?;
+    private closed;
+    /** Aborted on close — tears down any active stream and push readers. */
+    private readonly lifetime;
+    /**
+     * Set once a streaming command (e.g. MONITOR) hands back a `ResponseStream`.
+     * `command()` consumes its first frame as the immediate reply; {@link pushes}
+     * drains the rest. Pub/sub doesn't set this — its messages flow through the
+     * session push channel instead (see {@link pushes}).
+     */
+    private activeStream?;
+    private streamFrames?;
+    constructor(options: InMemoryRedisClientOptions);
+    /**
+     * Run a single command (e.g. `client.command('SET', 'k', 'v')`) and resolve
+     * to its native reply. Throws a {@link RedisCommandError} for `-ERR` replies,
+     * mirroring what a real client surfaces.
+     *
+     * Streaming commands (MONITOR / SUBSCRIBE / …) resolve to their *immediate*
+     * reply (MONITOR's `OK`, the subscribe confirmation); their server-initiated
+     * frames are delivered through {@link pushes}.
+     */
+    command(name: string, ...args: RedisCommandArgument[]): Promise<RedisNativeReply>;
+    /** Alias for {@link InMemoryRedisClient.command}. */
+    send(name: string, ...args: RedisCommandArgument[]): Promise<RedisNativeReply>;
+    /**
+     * True once the last command put the connection into *push mode* — an active
+     * MONITOR stream, or a SUBSCRIBE/PSUBSCRIBE/SSUBSCRIBE that entered subscribed
+     * mode. Consumers should switch to draining {@link pushes} while this holds.
+     */
+    get streaming(): boolean;
+    /**
+     * Server-initiated frames for a connection in *push mode* — pub/sub messages
+     * (via the session push channel) and the tail of a MONITOR stream — decoded to
+     * native replies. Iterate it after issuing SUBSCRIBE/PSUBSCRIBE/MONITOR. Ends
+     * when `signal` (or the connection) is closed.
+     */
+    pushes(signal?: AbortSignal): AsyncIterable<RedisNativeReply>;
+    close(): void;
+    private decode;
+}
+type CreateInMemoryRedisOptions = {
+    /** Logical database count (defaults to 16, matching real Redis). */
+    databaseCount?: number;
+    /** Pre-populate the keyspace before any connection is opened. */
+    seed?: readonly SeedEntry[];
+    /** Redis/Valkey version to emulate (defaults to `redis-8.0`). */
+    compatibility?: CompatibilitySpec;
+};
+/** Per-connection options for {@link InMemoryRedis.connect}. */
+type ConnectOptions = {
+    /** Initial selected database (default 0). */
+    database?: number;
+    /** Return `Buffer`s for bulk-string/verbatim replies instead of utf8 strings. */
+    returnBuffers?: boolean;
+};
+/**
+ * A socketless in-memory Redis *instance* — one shared keyspace + command
+ * pipeline that many {@link InMemoryRedisClient} connections can drive at once.
+ * Because connections share the underlying {@link RedisServerState}, a `MONITOR`
+ * / `SUBSCRIBE` on one connection observes commands run on another, and a
+ * `BLPOP` blocks until another connection writes the key — exactly like real
+ * Redis. `close()` tears the whole instance down.
+ */
+declare class InMemoryRedis {
+    private readonly state;
+    private readonly executor;
+    constructor(state: RedisServerState, executor: CommandExecutor);
+    /** Open a new connection (its own {@link ClientSession}) over this keyspace. */
+    connect(options?: ConnectOptions): InMemoryRedisClient;
+    close(): void;
+}
+/**
+ * Build a socketless {@link InMemoryRedis} instance with its own keyspace +
+ * command pipeline. Open one or more connections with {@link InMemoryRedis.connect}.
+ */
+declare function createInMemoryRedis(options?: CreateInMemoryRedisOptions): Promise<InMemoryRedis>;
+type CreateInMemoryClientOptions = CreateInMemoryRedisOptions & ConnectOptions;
+/**
+ * Convenience wrapper: an {@link InMemoryRedis} instance with a single owned
+ * connection. `client.close()` tears the whole instance down. For multiple
+ * connections over one keyspace (pub/sub, MONITOR, cross-connection blocking),
+ * use {@link createInMemoryRedis} and call `connect()` per connection.
+ */
+declare function createInMemoryClient(options?: CreateInMemoryClientOptions): Promise<InMemoryRedisClient>;
+
+/** A command argument node-redis accepts on the wire. */
+type NodeRedisCommandArgument = string | Buffer;
+/** Native JS value a reply decodes to (mirrors node-redis RESP2 defaults). */
+type NodeRedisReply = string | number | bigint | boolean | Buffer | null | NodeRedisReply[] | {
+    [key: string]: NodeRedisReply;
+};
+type NodeRedisMockClusterOptions = {
+    masters: number;
+    replicas?: number;
+};
+type CreateNodeRedisMockOptions = {
+    cluster?: undefined;
+    databaseCount?: number;
+} | {
+    cluster: NodeRedisMockClusterOptions;
+};
+/** A single `{ score, value }` member for ZADD-style methods. */
+type NodeRedisZMember = {
+    score: number;
+    value: string;
+};
+/** Listener invoked for each delivered pub/sub message: `(message, channel)`. */
+type NodeRedisPubSubListener = (message: string, channel: string) => void;
+/**
+ * Creates an in-memory node-redis-shaped client (standalone) or cluster client.
+ * Pass `{ cluster: { masters } }` for a {@link NodeRedisMockCluster}; otherwise
+ * a {@link NodeRedisMockClient} backed by a single in-memory pipeline.
+ */
+declare function createNodeRedisMock(options?: CreateNodeRedisMockOptions): Promise<NodeRedisMockClient | NodeRedisMockCluster>;
+type FacadeBackend = {
+    state: RedisServerState;
+    executor: CommandExecutor;
+};
+/**
+ * Shared command-method surface implemented by both the standalone client and
+ * the cluster client. Standalone runs every command on its own session; the
+ * cluster routes by slot to the owning node's session — but the curated method
+ * bodies are identical, so they live in this base and dispatch through the
+ * abstract {@link CommandRunner.run}.
+ */
+declare abstract class CommandRunner {
+    /**
+     * Execute one already-tokenised command and return its decoded reply.
+     * Implementations pick the session (standalone: the only one; cluster: the
+     * slot owner for the command's keys).
+     */
+    protected abstract run(args: NodeRedisCommandArgument[]): Promise<RedisValue>;
+    /** Generic escape hatch for any command, decoded to a native JS reply. */
+    sendCommand(args: NodeRedisCommandArgument[]): Promise<NodeRedisReply>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string | number, ...rest: NodeRedisCommandArgument[]): Promise<string | null>;
+    del(...keys: string[]): Promise<number>;
+    exists(...keys: string[]): Promise<number>;
+    incr(key: string): Promise<number>;
+    expire(key: string, seconds: number): Promise<number>;
+    ttl(key: string): Promise<number>;
+    hSet(key: string, field: string, value: string): Promise<number>;
+    hGet(key: string, field: string): Promise<string | null>;
+    hGetAll(key: string): Promise<{
+        [field: string]: string;
+    }>;
+    lPush(key: string, ...values: string[]): Promise<number>;
+    rPush(key: string, ...values: string[]): Promise<number>;
+    lRange(key: string, start: number, stop: number): Promise<string[]>;
+    sAdd(key: string, ...members: string[]): Promise<number>;
+    sMembers(key: string): Promise<string[]>;
+    zAdd(key: string, members: NodeRedisZMember | NodeRedisZMember[]): Promise<number>;
+    zRange(key: string, start: number, stop: number): Promise<string[]>;
+}
+type NodeRedisMockClientInit = FacadeBackend & {
+    database?: number;
+    /** True only for the client that created the state — it owns its teardown. */
+    ownsState?: boolean;
+};
+/**
+ * Standalone in-memory node-redis facade. Drives one {@link ClientSession}
+ * against a single keyspace; pub/sub uses a *dedicated* session that drains
+ * pushes off {@link ClientSession.readPushes}, mirroring node-redis' rule that a
+ * subscribed connection is reserved for pub/sub.
+ */
+declare class NodeRedisMockClient extends CommandRunner {
+    private readonly emitter;
+    private readonly backend;
+    private readonly database?;
+    private readonly ownsState;
+    private readonly session;
+    /**
+     * Serializes commands on this client the way a real single node-redis
+     * connection does, so a concurrent (un-awaited) call cannot interleave between
+     * the MULTI and EXEC of a transaction sharing {@link session}.
+     */
+    private commandLock;
+    /** Dedicated session + push-reader loop, created lazily on first subscribe. */
+    private pubsub?;
+    private closed;
+    constructor(init: NodeRedisMockClientInit);
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    once(event: string, listener: (...args: unknown[]) => void): this;
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    /** node-redis clients require an explicit connect(); here it is a no-op. */
+    connect(): Promise<this>;
+    /** A fresh, independent client over the **same** shared keyspace. */
+    duplicate(): Promise<NodeRedisMockClient>;
+    protected run(args: NodeRedisCommandArgument[]): Promise<RedisValue>;
+    /** Run `fn` after any in-flight command/transaction on this client settles. */
+    private runExclusive;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(channel: string, listener: NodeRedisPubSubListener): Promise<void>;
+    pSubscribe(pattern: string, listener: NodeRedisPubSubListener): Promise<void>;
+    unsubscribe(channel?: string): Promise<void>;
+    pUnsubscribe(pattern?: string): Promise<void>;
+    watch(...keys: string[]): Promise<string>;
+    unwatch(): Promise<string>;
+    /** Begin a MULTI transaction. Commands are queued, then replayed on exec(). */
+    multi(): NodeRedisMockMulti;
+    /** Replay MULTI → queued commands → EXEC on the shared session as one span. */
+    private runTransactionSpan;
+    /** Gracefully close: tear down pub/sub + the command session. */
+    quit(): Promise<string>;
+    /** Hard close (node-redis `disconnect()`). Same teardown as quit(). */
+    disconnect(): Promise<void>;
+    /**
+     * node-redis exposes a synchronous destroy(); abort everything immediately.
+     * The push-drain loop settles on the next tick via the abort signal.
+     */
+    destroy(): void;
+    private teardown;
+    private ensurePubSub;
+    private drainPushes;
+    private dispatchPush;
+}
+/**
+ * MULTI builder mirroring node-redis' chainable transaction API. Queues curated
+ * commands and replays them with a real MULTI/EXEC on the owning session, so the
+ * server's transaction + WATCH semantics drive the result (EXEC returns an array
+ * of replies, or `null` when a watched key changed).
+ */
+declare class NodeRedisMockMulti {
+    private readonly runTransaction;
+    private readonly queued;
+    private settled;
+    constructor(runTransaction: (queued: NodeRedisCommandArgument[][]) => Promise<RedisValue>);
+    set(key: string, value: string | number): this;
+    get(key: string): this;
+    del(...keys: string[]): this;
+    incr(key: string): this;
+    hSet(key: string, field: string, value: string): this;
+    hGet(key: string, field: string): this;
+    /** Generic escape hatch: queue any raw command. */
+    addCommand(args: NodeRedisCommandArgument[]): this;
+    private queue;
+    /**
+     * Replay the queued commands inside a real MULTI/EXEC and return the array of
+     * decoded replies. Matching node-redis, a watch-aborted transaction throws a
+     * `WatchError` (never returns null), and per-command errors are aggregated
+     * into a single `MultiErrorReply` carrying every reply + the error indexes.
+     */
+    exec(): Promise<NodeRedisReply[]>;
+    /** Cancel the transaction without running the queued commands. */
+    discard(): Promise<void>;
+    private assertOpen;
+}
+/**
+ * In-memory node-redis cluster facade. Reuses {@link buildClusterNodes} for a
+ * TCP-free cluster, then routes each command to the slot owner's session
+ * (computed via {@link RedisClusterTopology.calculateSlotForKeys}). The curated
+ * method surface is inherited unchanged from {@link CommandRunner}.
+ */
+declare class NodeRedisMockCluster extends CommandRunner {
+    private readonly emitter;
+    private readonly topology;
+    private readonly masters;
+    private readonly sessions;
+    private readonly replicationLinks;
+    private closed;
+    private constructor();
+    static create(options: NodeRedisMockClusterOptions): NodeRedisMockCluster;
+    on(event: string, listener: (...args: unknown[]) => void): this;
+    once(event: string, listener: (...args: unknown[]) => void): this;
+    off(event: string, listener: (...args: unknown[]) => void): this;
+    connect(): Promise<this>;
+    protected run(args: NodeRedisCommandArgument[]): Promise<RedisValue>;
+    quit(): Promise<string>;
+    disconnect(): Promise<void>;
+    destroy(): void;
+    private teardown;
+    /**
+     * Resolve (and cache) a session on the master that owns the slot for the
+     * command's keys. Keyless commands run on the first master.
+     */
+    private sessionForCommand;
+    private sessionFor;
+}
+
+export { CompatibilitySpec, type ConnectOptions, type CreateInMemoryClientOptions, type CreateInMemoryRedisOptions, type CreateIoredisMockOptions, type CreateNodeRedisMockOptions, type CreateRedisMockOptions, type CreateRedisServerClusterOptions, type CreateRedisServerOptions, InMemoryRedis, InMemoryRedisClient, type InMemoryRedisClientOptions, Logger, type NodeRedisCommandArgument, NodeRedisMockClient, NodeRedisMockCluster, type NodeRedisMockClusterOptions, NodeRedisMockMulti, type NodeRedisPubSubListener, type NodeRedisReply, type NodeRedisZMember, type RedisAddress, RedisCluster, RedisClusterNodeHandle, type RedisCommandArgument, type RedisMock, type RedisMockClusterOptions, type RedisNativeReply, type RedisServerHandle, type SeedEntry, createInMemoryClient, createInMemoryRedis, createIoredisMock, createNodeRedisMock, createRedisMock, createRedisServer, createValkeyMock, seedCluster, seedStandalone };