@iota-uz/sdk 0.4.13 → 0.4.15

package/dist/applet-runtime/index.mjs

@@ -0,0 +1,876 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import { z } from 'zod';
+
+// ui/src/applet-runtime/context.ts
+var requestContextStore = new AsyncLocalStorage();
+function withRequestContext(request, fn) {
+  return requestContextStore.run({ request }, fn);
+}
+function currentRequest() {
+  const ctx = requestContextStore.getStore();
+  if (!ctx?.request) {
+    throw new Error("No active applet request context. Use defineApplet({ fetch }) to establish request context.");
+  }
+  return ctx.request;
+}
+function currentRequestOptional() {
+  return requestContextStore.getStore()?.request;
+}
+
+// ui/src/applet-runtime/engine.ts
+var defaultEnginePath = "/rpc";
+function readEnv(name) {
+  const value = process.env[name];
+  if (!value || value.trim() === "") {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+function buildEngineURL(pathname) {
+  const socketPath = readEnv("IOTA_ENGINE_SOCKET");
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `http://localhost${path}?socket=${encodeURIComponent(socketPath)}`;
+}
+function randomID() {
+  const g = globalThis;
+  if (g.crypto?.randomUUID) {
+    return g.crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+async function postJSON(pathname, body, timeoutMs) {
+  const socketPath = readEnv("IOTA_ENGINE_SOCKET");
+  const request = currentRequestOptional();
+  const forwardedHeaders2 = {
+    "content-type": "application/json"
+  };
+  if (request) {
+    const maybeForwardHeader = (headerName) => {
+      const value = request.headers.get(headerName);
+      if (value && value.trim() !== "") {
+        forwardedHeaders2[headerName] = value;
+      }
+    };
+    maybeForwardHeader("x-iota-tenant-id");
+    maybeForwardHeader("x-iota-user-id");
+    maybeForwardHeader("x-iota-permissions");
+    maybeForwardHeader("x-iota-request-id");
+    maybeForwardHeader("cookie");
+    maybeForwardHeader("authorization");
+  }
+  const abortController = typeof timeoutMs === "number" && timeoutMs > 0 ? new AbortController() : void 0;
+  let timer;
+  try {
+    if (abortController && timeoutMs) {
+      timer = setTimeout(() => abortController.abort(), timeoutMs);
+    }
+    const init = {
+      method: "POST",
+      headers: forwardedHeaders2,
+      body: JSON.stringify(body),
+      signal: abortController?.signal,
+      unix: socketPath
+    };
+    const response = await fetch(buildEngineURL(pathname), init);
+    if (!response.ok) {
+      throw new Error(`engine RPC HTTP ${response.status}`);
+    }
+    return await response.json();
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+var engine = {
+  async call(method, params, options) {
+    const request = {
+      id: randomID(),
+      method,
+      params
+    };
+    const response = await postJSON(defaultEnginePath, request, options?.timeoutMs);
+    if (response.error) {
+      throw new Error(`${response.error.code}: ${response.error.message}`);
+    }
+    return response.result;
+  }
+};
+
+// ui/src/applet-runtime/ws.ts
+var connectionHandlers = /* @__PURE__ */ new Set();
+var messageHandlers = /* @__PURE__ */ new Set();
+var closeHandlers = /* @__PURE__ */ new Set();
+function appletMethod(op) {
+  const appletID = process.env.IOTA_APPLET_ID;
+  if (!appletID || appletID.trim() === "") {
+    throw new Error("IOTA_APPLET_ID is required");
+  }
+  return `${appletID}.ws.${op}`;
+}
+async function runHandlers(handlers, value) {
+  for (const handler of handlers) {
+    await handler(value);
+  }
+}
+async function runMessageHandlers(connectionId, data) {
+  for (const handler of messageHandlers) {
+    await handler(connectionId, data);
+  }
+}
+async function dispatchBridgeEvent(payload) {
+  if (payload.event === "open") {
+    await runHandlers(connectionHandlers, payload.connectionId);
+    return;
+  }
+  if (payload.event === "close") {
+    await runHandlers(closeHandlers, payload.connectionId);
+    return;
+  }
+  if (payload.event === "message") {
+    const decoded = Buffer.from(payload.dataBase64 ?? "", "base64");
+    await runMessageHandlers(payload.connectionId, new Uint8Array(decoded));
+  }
+}
+var ws = {
+  async send(connectionId, data) {
+    return engine.call(appletMethod("send"), { connectionId, data });
+  },
+  onConnection(handler) {
+    connectionHandlers.add(handler);
+    return () => connectionHandlers.delete(handler);
+  },
+  onMessage(handler) {
+    messageHandlers.add(handler);
+    return () => messageHandlers.delete(handler);
+  },
+  onClose(handler) {
+    closeHandlers.add(handler);
+    return () => closeHandlers.delete(handler);
+  }
+};
+
+// ui/src/applet-runtime/defineApplet.ts
+function requireUnixSocketPath() {
+  const path = process.env.IOTA_APPLET_SOCKET;
+  if (!path || path.trim() === "") {
+    throw new Error("IOTA_APPLET_SOCKET is required");
+  }
+  return path;
+}
+function defineApplet(definition) {
+  const socketPath = requireUnixSocketPath();
+  const bun = globalThis.Bun;
+  if (!bun || typeof bun.serve !== "function") {
+    throw new Error("defineApplet requires Bun runtime");
+  }
+  return bun.serve({
+    unix: socketPath,
+    fetch: (request) => withRequestContext(request, async () => {
+      const url = new URL(request.url);
+      if (request.method === "POST" && url.pathname === "/__ws") {
+        let payload;
+        try {
+          payload = await request.json();
+        } catch {
+          return new Response(JSON.stringify({ error: "invalid_json" }), {
+            status: 400,
+            headers: { "content-type": "application/json; charset=utf-8" }
+          });
+        }
+        if (!payload?.connectionId || !payload?.event) {
+          return new Response(JSON.stringify({ error: "invalid_payload" }), {
+            status: 400,
+            headers: { "content-type": "application/json; charset=utf-8" }
+          });
+        }
+        if (!["open", "message", "close"].includes(payload.event)) {
+          return new Response(JSON.stringify({ error: "invalid_payload" }), {
+            status: 400,
+            headers: { "content-type": "application/json; charset=utf-8" }
+          });
+        }
+        await dispatchBridgeEvent(payload);
+        return new Response(JSON.stringify({ ok: true }), {
+          status: 202,
+          headers: { "content-type": "application/json; charset=utf-8" }
+        });
+      }
+      return definition.fetch(request);
+    })
+  });
+}
+
+// ui/src/applet-runtime/auth.ts
+function requiredHeader(headers, name) {
+  const value = headers.get(name);
+  if (!value || value.trim() === "") {
+    throw new Error(`${name} header is required`);
+  }
+  return value;
+}
+var auth = {
+  async currentUser() {
+    const request = currentRequest();
+    const headers = request.headers;
+    const id2 = requiredHeader(headers, "x-iota-user-id");
+    const tenantId = requiredHeader(headers, "x-iota-tenant-id");
+    const permissionsHeader = headers.get("x-iota-permissions") ?? "";
+    const requestID = headers.get("x-iota-request-id") ?? void 0;
+    const permissions = permissionsHeader.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    return {
+      id: id2,
+      tenantId,
+      permissions,
+      requestId: requestID
+    };
+  }
+};
+
+// ui/src/applet-runtime/kv.ts
+function appletMethod2(op) {
+  const appletID = process.env.IOTA_APPLET_ID;
+  if (!appletID || appletID.trim() === "") {
+    throw new Error("IOTA_APPLET_ID is required");
+  }
+  return `${appletID}.kv.${op}`;
+}
+var kv = {
+  get(key) {
+    return engine.call(appletMethod2("get"), { key });
+  },
+  set(key, value, ttlSeconds) {
+    return engine.call(appletMethod2("set"), { key, value, ttlSeconds });
+  },
+  del(key) {
+    return engine.call(appletMethod2("del"), { key });
+  },
+  mget(keys) {
+    return engine.call(appletMethod2("mget"), { keys });
+  }
+};
+
+// ui/src/applet-runtime/db.ts
+function createDB(caller) {
+  class QueryIndexBuilder {
+    eq(field, value) {
+      this.constraint = { field, op: "eq", value };
+      return this;
+    }
+    build(name) {
+      if (!this.constraint) {
+        return void 0;
+      }
+      return { name, ...this.constraint };
+    }
+  }
+  class QueryFilterBuilder {
+    constructor() {
+      this.constraints = [];
+    }
+    eq(field, value) {
+      this.constraints.push({ field, op: "eq", value });
+      return this;
+    }
+    build() {
+      return this.constraints;
+    }
+  }
+  class RuntimeQueryBuilder {
+    constructor(table, options = {}) {
+      this.table = table;
+      this.options = options;
+    }
+    withIndex(name, build) {
+      const index = new QueryIndexBuilder();
+      build(index);
+      return new RuntimeQueryBuilder(this.table, {
+        ...this.options,
+        index: index.build(name)
+      });
+    }
+    filter(build) {
+      const filter = new QueryFilterBuilder();
+      build(filter);
+      return new RuntimeQueryBuilder(this.table, {
+        ...this.options,
+        filters: [...this.options.filters ?? [], ...filter.build()]
+      });
+    }
+    order(direction) {
+      return new RuntimeQueryBuilder(this.table, {
+        ...this.options,
+        order: direction
+      });
+    }
+    take(limit) {
+      return new RuntimeQueryBuilder(this.table, {
+        ...this.options,
+        take: limit
+      });
+    }
+    collect() {
+      return caller("query", { table: this.table, query: this.options });
+    }
+    async first() {
+      const rows = await this.take(1).collect();
+      return rows[0] ?? null;
+    }
+  }
+  const client = {
+    get(id2) {
+      return caller("get", { id: id2 });
+    },
+    query(table) {
+      return new RuntimeQueryBuilder(table);
+    },
+    queryRaw(table, query) {
+      return caller("query", { table, query: query ?? {} });
+    },
+    insert(table, value) {
+      return caller("insert", { table, value });
+    },
+    patch(id2, value) {
+      return caller("patch", { id: id2, value });
+    },
+    replace(id2, value) {
+      return caller("replace", { id: id2, value });
+    },
+    delete(id2) {
+      return caller("delete", { id: id2 });
+    }
+  };
+  return client;
+}
+var db = createDB((op, params) => engine.call(appletMethod3(op), params));
+function appletMethod3(op) {
+  const appletID = process.env.IOTA_APPLET_ID;
+  if (!appletID || appletID.trim() === "") {
+    throw new Error("IOTA_APPLET_ID is required");
+  }
+  return `${appletID}.db.${op}`;
+}
+
+// ui/src/applet-runtime/jobs.ts
+function appletMethod4(op) {
+  const appletID = process.env.IOTA_APPLET_ID;
+  if (!appletID || appletID.trim() === "") {
+    throw new Error("IOTA_APPLET_ID is required");
+  }
+  return `${appletID}.jobs.${op}`;
+}
+var jobs = {
+  enqueue(method, params) {
+    return engine.call(appletMethod4("enqueue"), { method, params: params ?? {} });
+  },
+  schedule(cron, method, params) {
+    return engine.call(appletMethod4("schedule"), { cron, method, params: params ?? {} });
+  },
+  list() {
+    return engine.call(appletMethod4("list"), {});
+  },
+  cancel(id2) {
+    return engine.call(appletMethod4("cancel"), { id: id2 });
+  }
+};
+
+// ui/src/applet-runtime/secrets.ts
+function appletMethod5(op) {
+  const appletID = process.env.IOTA_APPLET_ID;
+  if (!appletID || appletID.trim() === "") {
+    throw new Error("IOTA_APPLET_ID is required");
+  }
+  return `${appletID}.secrets.${op}`;
+}
+var secrets = {
+  async get(name) {
+    const response = await engine.call(appletMethod5("get"), { name });
+    return response.value;
+  }
+};
+
+// ui/src/applet-runtime/files.ts
+function readEnv2(name) {
+  const value = process.env[name];
+  if (!value || value.trim() === "") {
+    throw new Error(`${name} is required`);
+  }
+  return value;
+}
+function appletMethod6(op) {
+  const appletID = process.env.IOTA_APPLET_ID;
+  if (!appletID || appletID.trim() === "") {
+    throw new Error("IOTA_APPLET_ID is required");
+  }
+  return `${appletID}.files.${op}`;
+}
+function buildEngineURL2(pathname, socketPath) {
+  const path = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return `http://localhost${path}?socket=${encodeURIComponent(socketPath)}`;
+}
+function forwardedHeaders() {
+  const request = currentRequestOptional();
+  const headers = {};
+  if (!request) {
+    return headers;
+  }
+  const maybeForwardHeader = (headerName) => {
+    const value = request.headers.get(headerName);
+    if (value && value.trim() !== "") {
+      headers[headerName] = value;
+    }
+  };
+  maybeForwardHeader("x-iota-tenant-id");
+  maybeForwardHeader("x-iota-user-id");
+  maybeForwardHeader("x-iota-request-id");
+  return headers;
+}
+async function toBytes(data) {
+  if (data instanceof Blob) {
+    const buffer = await data.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+async function toBase64(data) {
+  const bytes = await toBytes(data);
+  return Buffer.from(bytes).toString("base64");
+}
+async function requestFilesEndpoint(path, options) {
+  const socketPath = readEnv2("IOTA_ENGINE_SOCKET");
+  const headers = new Headers(options.headers);
+  headers.set("X-Iota-Applet-Id", options.appletId);
+  for (const [name, value] of Object.entries(forwardedHeaders())) {
+    headers.set(name, value);
+  }
+  const response = await fetch(buildEngineURL2(path, socketPath), {
+    ...options,
+    headers,
+    unix: socketPath
+  });
+  if (!response.ok) {
+    throw new Error(`files endpoint HTTP ${response.status}`);
+  }
+  return await response.json();
+}
+var files = {
+  async store(input) {
+    const appletID = readEnv2("IOTA_APPLET_ID");
+    try {
+      const bytes = await toBytes(input.data);
+      const exactBuffer = bytes.buffer instanceof ArrayBuffer ? bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) : Uint8Array.from(bytes).buffer;
+      return await requestFilesEndpoint("/files/store", {
+        appletId: appletID,
+        method: "POST",
+        headers: {
+          "X-Iota-File-Name": input.name,
+          "X-Iota-Content-Type": input.contentType ?? "",
+          "Content-Type": input.contentType ?? "application/octet-stream"
+        },
+        body: new Blob([exactBuffer], { type: input.contentType ?? "application/octet-stream" })
+      });
+    } catch (error) {
+      if (error instanceof TypeError || error instanceof ReferenceError) {
+        throw error;
+      }
+      const dataBase64 = await toBase64(input.data);
+      return engine.call(appletMethod6("store"), {
+        name: input.name,
+        contentType: input.contentType ?? "",
+        dataBase64
+      });
+    }
+  },
+  async get(id2) {
+    const appletID = readEnv2("IOTA_APPLET_ID");
+    try {
+      return await requestFilesEndpoint(`/files/get?id=${encodeURIComponent(id2)}&applet=${encodeURIComponent(appletID)}`, {
+        appletId: appletID,
+        method: "GET"
+      });
+    } catch (error) {
+      if (error instanceof TypeError || error instanceof ReferenceError) {
+        throw error;
+      }
+      return engine.call(appletMethod6("get"), { id: id2 });
+    }
+  },
+  async delete(id2) {
+    const appletID = readEnv2("IOTA_APPLET_ID");
+    try {
+      const result = await requestFilesEndpoint(`/files/delete?id=${encodeURIComponent(id2)}&applet=${encodeURIComponent(appletID)}`, {
+        appletId: appletID,
+        method: "DELETE"
+      });
+      return result.ok;
+    } catch (error) {
+      if (error instanceof TypeError || error instanceof ReferenceError) {
+        throw error;
+      }
+      return engine.call(appletMethod6("delete"), { id: id2 });
+    }
+  }
+};
+var RuntimeTableDefinition = class _RuntimeTableDefinition {
+  constructor(schema, indexes = []) {
+    this.schema = schema;
+    this.indexes = indexes;
+  }
+  index(name, fields) {
+    return new _RuntimeTableDefinition(this.schema, [
+      ...this.indexes,
+      {
+        name,
+        fields: [...fields]
+      }
+    ]);
+  }
+};
+function defineTable(shape) {
+  return new RuntimeTableDefinition(z.object(shape));
+}
+function defineSchema(tables) {
+  return { tables };
+}
+function id(_tableName) {
+  return z.string().min(1);
+}
+
+// ui/src/applet-runtime/test-context.ts
+var defaultUser = {
+  id: "test-user",
+  tenantId: "test-tenant",
+  permissions: []
+};
+function normalizeUser(user) {
+  return {
+    ...defaultUser,
+    ...user ?? {},
+    permissions: user?.permissions ? [...user.permissions] : []
+  };
+}
+function randomID2(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function toNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  return Number.NaN;
+}
+function nestedValue(input, field) {
+  let current = input;
+  for (const segment of field.split(".")) {
+    if (!current || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function matchesConstraint(value, constraint) {
+  if (constraint.op !== "eq") {
+    return false;
+  }
+  return String(nestedValue(value, constraint.field)) === String(constraint.value);
+}
+function filterDocuments(documents, options) {
+  let result = [...documents];
+  if (options.index) {
+    result = result.filter((doc) => matchesConstraint(doc.value, options.index));
+  }
+  for (const filter of options.filters ?? []) {
+    result = result.filter((doc) => matchesConstraint(doc.value, filter));
+  }
+  result.sort((a, b) => options.order === "asc" ? a.updatedAt - b.updatedAt : b.updatedAt - a.updatedAt);
+  if (typeof options.take === "number" && options.take > 0) {
+    result = result.slice(0, options.take);
+  }
+  return result;
+}
+function parseBase64Payload(data) {
+  if (typeof data !== "string" || data.trim() === "") {
+    throw new Error("dataBase64 is required");
+  }
+  return data;
+}
+async function toBase642(data) {
+  if (data instanceof Blob) {
+    const buffer = await data.arrayBuffer();
+    return Buffer.from(buffer).toString("base64");
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("base64");
+  }
+  return Buffer.from(data).toString("base64");
+}
+function createTestContext(options = {}) {
+  const appletId = options.appletId?.trim() || "test";
+  let currentUser = normalizeUser(options.user);
+  const customHandlers = options.engineHandlers ?? {};
+  const secretStore = new Map(Object.entries(options.secrets ?? {}));
+  const kvStore = /* @__PURE__ */ new Map();
+  const dbStore = /* @__PURE__ */ new Map();
+  const jobsStore = /* @__PURE__ */ new Map();
+  const filesStore = /* @__PURE__ */ new Map();
+  function scopedKey(key) {
+    return `${currentUser.tenantId}::${appletId}::${key}`;
+  }
+  async function dbCall(op, params) {
+    switch (op) {
+      case "get": {
+        const id2 = String(params.id ?? "");
+        const record = dbStore.get(id2);
+        return record ? { _id: record.id, table: record.table, value: record.value } : null;
+      }
+      case "query": {
+        const table = String(params.table ?? "");
+        const query = params.query ?? {};
+        const rows = filterDocuments(
+          [...dbStore.values()].filter((doc) => doc.table === table),
+          query
+        );
+        return rows.map((doc) => ({ _id: doc.id, table: doc.table, value: doc.value }));
+      }
+      case "insert": {
+        const id2 = randomID2("doc");
+        const now = Date.now();
+        const record = {
+          id: id2,
+          table: String(params.table ?? ""),
+          value: params.value,
+          createdAt: now,
+          updatedAt: now
+        };
+        dbStore.set(id2, record);
+        return { _id: id2, table: record.table, value: record.value };
+      }
+      case "patch": {
+        const id2 = String(params.id ?? "");
+        const current = dbStore.get(id2);
+        if (!current) {
+          return null;
+        }
+        const currentValue = current.value;
+        const nextValue = params.value;
+        const next = {
+          ...current,
+          value: currentValue && typeof currentValue === "object" && !Array.isArray(currentValue) && nextValue && typeof nextValue === "object" && !Array.isArray(nextValue) ? { ...currentValue, ...nextValue } : nextValue,
+          updatedAt: Date.now()
+        };
+        dbStore.set(id2, next);
+        return { _id: id2, table: next.table, value: next.value };
+      }
+      case "replace": {
+        const id2 = String(params.id ?? "");
+        const current = dbStore.get(id2);
+        if (!current) {
+          return null;
+        }
+        const next = {
+          ...current,
+          value: params.value,
+          updatedAt: Date.now()
+        };
+        dbStore.set(id2, next);
+        return { _id: id2, table: next.table, value: next.value };
+      }
+      case "delete": {
+        const id2 = String(params.id ?? "");
+        return dbStore.delete(id2);
+      }
+      default:
+        throw new Error(`unknown db op: ${op}`);
+    }
+  }
+  const db2 = createDB((op, params) => dbCall(op, params));
+  const engine2 = {
+    async call(method, params) {
+      if (customHandlers[method]) {
+        return await customHandlers[method](params);
+      }
+      const chunks = method.split(".");
+      if (chunks.length < 3 || chunks[0] !== appletId) {
+        throw new Error(`unsupported method: ${method}`);
+      }
+      const namespace = chunks[1];
+      const op = chunks.slice(2).join(".");
+      const payload = params ?? {};
+      if (namespace === "kv") {
+        const key = String(payload.key ?? "");
+        const storageKey = scopedKey(key);
+        if (op === "get") {
+          return kvStore.get(storageKey) ?? null;
+        }
+        if (op === "set") {
+          kvStore.set(storageKey, payload.value);
+          return void 0;
+        }
+        if (op === "del") {
+          return kvStore.delete(storageKey);
+        }
+        if (op === "mget") {
+          const keys = Array.isArray(payload.keys) ? payload.keys.map((v) => String(v)) : [];
+          return keys.map((k) => kvStore.get(scopedKey(k)) ?? null);
+        }
+      }
+      if (namespace === "db") {
+        return dbCall(op, payload);
+      }
+      if (namespace === "jobs") {
+        if (op === "enqueue") {
+          const id2 = randomID2("job");
+          const record = {
+            id: id2,
+            type: "one_off",
+            cron: "",
+            method: String(payload.method ?? ""),
+            params: payload.params ?? {},
+            status: "queued",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          jobsStore.set(id2, record);
+          return record;
+        }
+        if (op === "schedule") {
+          const id2 = randomID2("job");
+          const record = {
+            id: id2,
+            type: "scheduled",
+            cron: String(payload.cron ?? ""),
+            method: String(payload.method ?? ""),
+            params: payload.params ?? {},
+            status: "scheduled",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          jobsStore.set(id2, record);
+          return record;
+        }
+        if (op === "list") {
+          return [...jobsStore.values()];
+        }
+        if (op === "cancel") {
+          const id2 = String(payload.id ?? "");
+          return { ok: jobsStore.delete(id2) };
+        }
+      }
+      if (namespace === "secrets" && op === "get") {
+        const name = String(payload.name ?? "");
+        const value = secretStore.get(name);
+        if (value === void 0) {
+          throw new Error(`secret not found: ${name}`);
+        }
+        return { value };
+      }
+      if (namespace === "files") {
+        if (op === "store") {
+          const id2 = randomID2("file");
+          const name = String(payload.name ?? "file.bin");
+          const dataBase64 = parseBase64Payload(payload.dataBase64);
+          const contentType = String(payload.contentType ?? "");
+          const size = Buffer.from(dataBase64, "base64").byteLength;
+          const record = {
+            id: id2,
+            name,
+            contentType,
+            size,
+            path: `/test/${currentUser.tenantId}/${appletId}/${id2}-${name}`,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            dataBase64
+          };
+          filesStore.set(id2, record);
+          return record;
+        }
+        if (op === "get") {
+          const id2 = String(payload.id ?? "");
+          const record = filesStore.get(id2);
+          if (!record) {
+            return null;
+          }
+          const { dataBase64: _, ...rest } = record;
+          return rest;
+        }
+        if (op === "delete") {
+          const id2 = String(payload.id ?? "");
+          return filesStore.delete(id2);
+        }
+      }
+      throw new Error(`unsupported method: ${method}`);
+    }
+  };
+  return {
+    auth: {
+      async currentUser() {
+        return currentUser;
+      }
+    },
+    engine: engine2,
+    kv: {
+      async get(key) {
+        return kvStore.get(scopedKey(key)) ?? null;
+      },
+      async set(key, value, ttlSeconds) {
+        if (!Number.isNaN(toNumber(ttlSeconds)) && ttlSeconds <= 0) {
+          kvStore.delete(scopedKey(key));
+          return;
+        }
+        kvStore.set(scopedKey(key), value);
+      },
+      async del(key) {
+        return kvStore.delete(scopedKey(key));
+      },
+      async mget(keys) {
+        return keys.map((key) => kvStore.get(scopedKey(key)) ?? null);
+      }
+    },
+    db: db2,
+    jobs: {
+      enqueue(method, params) {
+        return engine2.call(`${appletId}.jobs.enqueue`, { method, params: params ?? {} });
+      },
+      schedule(cron, method, params) {
+        return engine2.call(`${appletId}.jobs.schedule`, { cron, method, params: params ?? {} });
+      },
+      list() {
+        return engine2.call(`${appletId}.jobs.list`, {});
+      },
+      cancel(id2) {
+        return engine2.call(`${appletId}.jobs.cancel`, { id: id2 });
+      }
+    },
+    secrets: {
+      async get(name) {
+        const result = await engine2.call(`${appletId}.secrets.get`, { name });
+        return result.value;
+      }
+    },
+    files: {
+      async store(input) {
+        const dataBase64 = await toBase642(input.data);
+        return engine2.call(`${appletId}.files.store`, {
+          name: input.name,
+          contentType: input.contentType ?? "",
+          dataBase64
+        });
+      },
+      get(id2) {
+        return engine2.call(`${appletId}.files.get`, { id: id2 });
+      },
+      delete(id2) {
+        return engine2.call(`${appletId}.files.delete`, { id: id2 });
+      }
+    },
+    setCurrentUser(nextUser) {
+      currentUser = normalizeUser(nextUser);
+    }
+  };
+}
+
+export { auth, createTestContext, db, defineApplet, defineSchema, defineTable, engine, files, id, jobs, kv, secrets, ws };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map