@xanots/sdk 0.0.1

package/dist/node.d.ts

@@ -0,0 +1,59 @@
+import { aT as LambdaOptions, aU as CaptureValue, aV as LambdaSurface, aW as CaptureRecord, aX as LambdaBindings, F as FunctionDef, aY as Xano, h as LockFile } from './store-BQ97nKIF.js';
+export { aZ as AddonDef, a_ as AddonXdo, A as AdoptChange, a as AdoptResult, a$ as AgentDef, b0 as AgentHandle, b1 as AgentOutput, b2 as AgentSettingsXdo, b3 as AgentXdo, b4 as AmbientBindings, b5 as AnthropicLlm, b6 as ApiGroupDef, b7 as ApiGroupXdo, b8 as AuthRef, b9 as Authored, B as Bundle, b as BundlePayload, c as BundleType, ba as Capturable, bb as ChannelConversationDef, bc as ChannelDeliveryDef, bd as ChannelDeliveryGuarantee, be as ChannelPublishDef, bf as ChannelPublishWho, bg as ChannelRateLimitDef, bh as ColumnDef, bi as Comparison, bj as ContainerEnv, bk as ContainerPort, bl as ContainerResources, bm as ContainerVolume, bn as CorsConfig, bo as CorsMode, bp as DatabaseActions, bq as DatabaseInputs, br as DbEval, bs as DbEvalFilter, bt as DbWhere, bu as ErrorInputs, bv as ExceptionPolicy, bw as FieldAccessor, bx as FieldRule, by as GoogleGenAiLlm, bz as HistoryInput, bA as HttpVerb, bB as IndexDef, bC as IndexLang, bD as IndexOp, bE as IndexType, bF as IndexXdo, bG as InferRow, bH as InputDescriptor, bI as InputOptions, bJ as IteratingBindings, bK as LAMBDA_BINDINGS, bL as LAMBDA_CODE_FILTERS, bM as LAMBDA_GLOBALS, bN as LAMBDA_MODULE_GLOBALS, bO as LAMBDA_STATEMENTS, bP as LambdaBody, bQ as LlmPrompt, bR as LlmProvider, bS as LlmSettings, f as LockEntry, g as LockExportContext, M as Manifest, i as ManifestField, j as ManifestKind, k as ManifestStatement, bT as ManifestValue, bU as McpPathOptions, bV as McpServerDef, bW as McpServerHandle, bX as McpServerXdo, l as MergeResult, bY as MessageDeliverTo, bZ as MicroserviceChart, b_ as MicroserviceConfig, b$ as MicroserviceContainer, c0 as MicroserviceDef, c1 as MicroserviceDeployment, c2 as MicroserviceIngress, c3 as MicroserviceRegistryAuth, c4 as MicroserviceVolume, c5 as MicroserviceXdo, c6 as MiddlewareAttach, c7 as MiddlewareAttachEntry, c8 as MiddlewareDef, c9 as MiddlewareXdo, O as ObjectKind, ca as OpenAiLlm, m as PayloadArrayKey, cb as QueryDef, cc as QueryFilterName, cd as QueryHandle, ce as QueryResponseType, cf as QueryXdo, cg as RealtimeActions, ch as RealtimeChannelActions, ci as RealtimeChannelDef, cj as RealtimeChannelHandle, ck as RealtimeChannelRef, cl as RealtimeChannelTriggerInputs, cm as RealtimeChannelXdo, cn as RealtimeClient, co as RealtimeInputs, cp as RealtimeMessageDef, cq as RealtimeMessageXdo, cr as RealtimeServerActions, cs as RealtimeServerDef, ct as RealtimeServerHandle, cu as RealtimeServerRef, cv as RealtimeServerTriggerInputs, cw as RealtimeServerXdo, cx as RealtimeUrlOptions, R as RenameResult, cy as ResultStrategy, cz as Route, cA as RowOf, cB as ScheduleDef, cC as SchemaCols, cD as SchemaDef, cE as SearchComparison, cF as SearchGroup, cG as SearchNode, cH as SearchOp, cI as SearchParamValue, cJ as SeedFileSource, cK as SeedRow, cL as SeedSource, cM as SortDir, cN as SortDirective, S as StatementSpec, cO as TableDef, cP as TableXdo, cQ as TaskDef, cR as TaskXdo, cS as ToolDef, cT as ToolXdo, cU as ToolsetBaseDef, cV as ToolsetBaseXdo, cW as ToolsetInputs, cX as ToolsetToolEntry, cY as ToolsetToolRef, cZ as TriggerDef, c_ as TriggerObjType, c$ as TriggerXdo, d0 as ViewDef, d1 as ViewXdo, d2 as WorkflowTestDef, d3 as WorkflowTestXdo, d4 as WorkspaceActions, d5 as WorkspaceConfigDef, d6 as WorkspaceConfigXdo, d7 as WorkspaceHistoryDef, d8 as WorkspaceHistoryXdo, d9 as WorkspaceInputs, da as WorkspaceMiddlewareDef, db as WorkspaceMiddlewareXdo, dc as XanoFreeLlm, dd as addon, de as agent, df as agentTrigger, dg as and, dh as apiGroup, di as assertLambdaBody, dj as bitwiseAnd, dk as bitwiseOr, dl as bitwiseXor, dm as cmp, dn as defineFunction, dp as emit, dq as emitBundle, dr as errorTrigger, ds as expr, dt as fl, du as input, dv as mathAdd, dw as mathDiv, dx as mathMul, dy as mathSub, dz as mcpServer, dA as mcpServerTrigger, dB as microservice, dC as middleware, dD as mixed, dE as objectEntries, dF as objectKeys, dG as objectValues, dH as or, dI as query, dJ as realtimeChannel, dK as realtimeChannelTrigger, dL as realtimeMessage, dM as realtimeServer, dN as realtimeServerTrigger, dO as realtimeTrigger, dP as resetLockOverrides, dQ as seedFile, dR as seedLockOverrides, dS as table, dT as tableTrigger, dU as task, dV as textAppend, dW as textPrepend, dX as toSearchParams, dY as tool, dZ as workflowTest, d_ as workspace, d$ as workspaceConfig, e0 as workspaceTrigger } from './store-BQ97nKIF.js';
+export { ActionCallArgs, AddonCallArgs, AddonSpec, AgentRunResult, AiAgentRunArgs, AnyAddonDef, AnyFunctionDef, AnyQueryDef, AnyTableDef, ApiCallArgs, ApplyFilter, ApplyFilters, ArrayMapArgs, CloudJobArgs, CloudJobAwaitArgs, CloudJobStatusArgs, CreateAuthTokenArgs, DbAddArgs, DbAddOrEditArgs, DbAggregate, DbAggregatePaging, DbBind, DbBulkAddArgs, DbBulkDeleteArgs, DbBulkWriteArgs, DbDelArgs, DbDirectQueryArgs, DbDistinct, DbEditArgs, DbExternal, DbExternalPermissions, DbExternalQueryArgs, DbField, DbGetArgs, DbHasArgs, DbJoin, DbPaging, DbPatchArgs, DbQueryArgs, DbResponseType, DbReturnType, DbSchemaArgs, DbTransactionArgs, DbTruncateArgs, ExpectToThrowArgs, ExternalSqlEngine, ForArgs, ForeachArgs, FunctionCallArgs, FunctionRunArgs, GetRawInputArgs, HeaderMap, HttpMethod, InferInput, InferResponse, IpLookupArgs, IpLookupResult, MiddlewareCallArgs, RealtimeEventArgs, StackTupleWidened, SwitchArgs, SwitchCaseArgs, TaskCallArgs, ToolCallArgs, TriggerCallArgs, TryCatchArgs, WhileArgs, WorkflowTestCallArgs, actionCall, actionPackageCall, addonCall, aiAgentRun, apiCall, arrayMap, arrayUnion, cloudJob, cloudJobAwait, cloudJobStatus, comment, compile, conditional, createAuthToken, dbAdd, dbAddOrEdit, dbBulkAdd, dbBulkDelete, dbBulkPatch, dbBulkUpdate, dbDel, dbDirectQuery, dbEdit, dbExternalQuery, dbGet, dbHas, dbPatch, dbQuery, dbSchema, dbTransaction, dbTruncate, debugLog, die, expectToThrow, fileUrl, forLoop, foreachBreak, foreachContinue, foreachLoop, foreachRemove, functionCall, functionRun, getRawInput, group, ignored, ipLookup, middlewareCall, postProcess, realtimeEvent, returnValue, s, setVar, switchCase, switchStatement, taskCall, toolCall, triggerCall, tryCatch, updateVar, whileLoop, workflowTestCall } from './index.js';
+import { V as Value } from './response-CVAE2kMj.js';
+export { B as BrandOpts, c as BrandValue, C as CacheXdo, f as CaughtField, h as ConditionalContext, j as ConditionalElifContext, D as DecimalMethod, E as EmailMethod, k as ExprGroup, l as ExprNode, m as ExprOperand, n as ExprStatement, o as FieldAccess, p as FieldDescriptor, q as FieldMap, s as FieldOpts, u as FieldStyleType, v as FieldXdo, w as FilterXdo, x as FilteredValue, y as FromFieldMap, F as FunctionXdo, H as HistoryXdo, I as InputXdo, z as IntMethod, L as ListBoundsXdo, M as MethodArg, A as MethodOpts, G as MethodSpec, J as MethodXdo, K as MockEntry, N as MockMap, O as MockXdo, P as ObjInput, Q as ObjMember, S as ObjValue, T as ObjectRef, U as PasswordMethod, W as PersistedFunctionRow, X as RefValue, Y as RegexValue, Z as ResponseDef, _ as ResultItemXdo, $ as RowFromFieldMap, a0 as StackItemXdo, a1 as Statement, a2 as StatementAnnotations, a3 as StatementInputXdo, a4 as StatementOptions, a5 as TAGS, a6 as TEST_EXPECT_TYPES, a7 as TableRefMethod, a8 as Tag, a9 as TaggedValue, aa as TestDef, ab as TestExpect, ac as TestExpectType, ad as TestXdo, ae as TextFormat, af as TextMethod, ag as TypeBrand, ah as ValueOf, ai as VectorMethod, aj as XanoFileRef, ak as XanoGeoPosition, al as XanoGeoValue, am as annotate, an as auth, ao as c, ap as caught, aq as col, ar as env, as as expect, at as f, au as filter, av as inp, aw as obj, ax as out, ay as ref, az as resp, aA as setting, aB as statements, aC as sys, aD as test, aE as toolset, aF as withFilters } from './response-CVAE2kMj.js';
+export { exportBundleJson, loadDefault, parseArgs, run } from './cli.js';
+
+/**
+ * Read a lambda body from its own module.
+ *
+ * `path` resolves against the CALLING module's directory (like an `import`), not
+ * the process working directory. The file must default-export exactly one
+ * function; its body is extracted and validated exactly as {@link lam.fn}'s is.
+ */
+declare function file(path: string, opts?: LambdaOptions<Record<string, CaptureValue>>): Value;
+/**
+ * Lambda authoring, with the filesystem form attached.
+ *
+ * Identical to the `lam` exported from `@xanots/sdk`, plus {@link file}. The
+ * isomorphic entry deliberately does not carry it: reading a file is not
+ * something a browser bundle can do, and a workspace definition shared with a
+ * frontend must keep resolving.
+ */
+declare const lam: {
+    file: typeof file;
+    fn: <S extends LambdaSurface = "reduce", C extends CaptureRecord<C> = Record<string, never>>(body: (bindings: LambdaBindings<S>, captured: C) => unknown, opts?: LambdaOptions<C> & {
+        surface?: S;
+    }) => Value;
+    raw: (code: string, opts?: LambdaOptions<Record<string, CaptureValue>>) => Value;
+};
+
+/** Compile a function and write the JSON artifact to `path`. */
+declare function writeArtifact(fn: FunctionDef, path: string, opts?: {
+    indent?: number;
+}): void;
+/**
+ * Write the aggregate bundle to `path`.
+ *
+ * `opts.strict` fails the write on any build warning instead of printing it —
+ * the same switch `xanots export --strict` throws (issue #15). A script that
+ * writes a bundle nobody watches is exactly where a printed warning is lost.
+ */
+declare function writeBundle(xano: Xano, path: string, opts?: {
+    indent?: number;
+    strict?: boolean;
+}): void;
+
+/** Read + strictly validate a lock file from disk. The file must exist. */
+declare function readLockFile(path: string): LockFile;
+/**
+ * Atomic, idempotent write: unchanged bytes are not rewritten (mtime stays
+ * put, watchers stay quiet); changed content lands via temp-file+rename so a
+ * crash can never leave a half-written lock.
+ *
+ * Returns true when the file was (re)written.
+ */
+declare function writeLockFile(path: string, lock: LockFile): boolean;
+
+export { CaptureRecord, CaptureValue, FunctionDef, LambdaBindings, LambdaOptions, LambdaSurface, LockFile, Value, Xano, lam, readLockFile, writeArtifact, writeBundle, writeLockFile };

package/dist/node.js

@@ -0,0 +1,442 @@
+import {
+  defineFunction,
+  fileUrl
+} from "./chunk-4YMD2OOZ.js";
+import {
+  TEST_EXPECT_TYPES,
+  expect
+} from "./chunk-MZUI3JNX.js";
+import {
+  addon,
+  agent,
+  apiGroup,
+  mcpServer,
+  middleware,
+  realtimeMessage,
+  realtimeServer,
+  task,
+  tool,
+  workflowTest
+} from "./chunk-YDZYMZBE.js";
+import {
+  actionCall,
+  actionPackageCall,
+  addonCall,
+  agentTrigger,
+  aiAgentRun,
+  apiCall,
+  arrayMap,
+  arrayUnion,
+  bitwiseAnd,
+  bitwiseOr,
+  bitwiseXor,
+  cloudJob,
+  cloudJobAwait,
+  cloudJobStatus,
+  comment,
+  createAuthToken,
+  dbAdd,
+  dbAddOrEdit,
+  dbBulkAdd,
+  dbBulkDelete,
+  dbBulkPatch,
+  dbBulkUpdate,
+  dbDel,
+  dbDirectQuery,
+  dbEdit,
+  dbExternalQuery,
+  dbGet,
+  dbHas,
+  dbPatch,
+  dbQuery,
+  dbSchema,
+  dbTransaction,
+  dbTruncate,
+  debugLog,
+  die,
+  errorTrigger,
+  expectToThrow,
+  forLoop,
+  foreachBreak,
+  foreachContinue,
+  foreachLoop,
+  foreachRemove,
+  functionCall,
+  functionRun,
+  getRawInput,
+  group,
+  ignored,
+  ipLookup,
+  mathAdd,
+  mathDiv,
+  mathMul,
+  mathSub,
+  mcpServerTrigger,
+  microservice,
+  middlewareCall,
+  objectEntries,
+  objectKeys,
+  objectValues,
+  postProcess,
+  realtimeChannel,
+  realtimeChannelTrigger,
+  realtimeEvent,
+  realtimeServerTrigger,
+  realtimeTrigger,
+  returnValue,
+  s,
+  setVar,
+  switchCase,
+  switchStatement,
+  tableTrigger,
+  taskCall,
+  textAppend,
+  textPrepend,
+  toolCall,
+  triggerCall,
+  tryCatch,
+  updateVar,
+  whileLoop,
+  workflowTestCall,
+  workspaceConfig,
+  workspaceTrigger
+} from "./chunk-FJ6ZS5KB.js";
+import {
+  exportBundleJson,
+  loadDefault,
+  parseArgs,
+  run,
+  writeArtifact,
+  writeBundle
+} from "./chunk-YGPIY3WT.js";
+import "./chunk-IZW6MK3U.js";
+import "./chunk-EZG76F7R.js";
+import {
+  Xano,
+  workspace
+} from "./chunk-3DUAGYGP.js";
+import "./chunk-YYRDLFSJ.js";
+import {
+  LAMBDA_BINDINGS,
+  LAMBDA_CODE_FILTERS,
+  LAMBDA_GLOBALS,
+  LAMBDA_MODULE_GLOBALS,
+  LAMBDA_STATEMENTS,
+  and,
+  assertLambdaBody,
+  auth,
+  c,
+  caught,
+  cmp,
+  col,
+  compile,
+  conditional,
+  emit,
+  emitBundle,
+  env,
+  expr,
+  extractFunctionBody,
+  f,
+  filter,
+  fl,
+  inp,
+  input,
+  lam,
+  lambdaValue,
+  maskNonCode,
+  mixed,
+  obj,
+  or,
+  out,
+  query,
+  ref,
+  resp,
+  seedFile,
+  setting,
+  sys,
+  table,
+  test,
+  toSearchParams,
+  toolset,
+  withFilters
+} from "./chunk-EMCAWMHC.js";
+import "./chunk-WHOJWOSV.js";
+import {
+  annotate,
+  statements
+} from "./chunk-LH6Z6KFV.js";
+import {
+  readLockFile,
+  writeLockFile
+} from "./chunk-HJPTWBLH.js";
+import "./chunk-GNPVYOPB.js";
+import {
+  resetLockOverrides,
+  seedLockOverrides
+} from "./chunk-4HT3BNZ7.js";
+
+// src/values/lambda-file.ts
+import { readFileSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+import { fileURLToPath } from "url";
+var PREFIX = "lam.file";
+var LOADER_FRAME = /[/\\]node_modules[/\\](?:\.pnpm[/\\][^/\\]+[/\\]node_modules[/\\])?(?:vite-node|vite|vitest|tsx|ts-node|jiti|esbuild-register|@esbuild-kit)[/\\]/;
+var SELF = fileURLToPath(import.meta.url);
+function callerDir() {
+  const stack = new Error().stack ?? "";
+  const frames = [];
+  for (const line of stack.split("\n").slice(1)) {
+    const match = /\((.*?):\d+:\d+\)\s*$/.exec(line) ?? /at (.*?):\d+:\d+\s*$/.exec(line);
+    const raw = match?.[1];
+    if (raw === void 0 || raw.startsWith("node:")) continue;
+    const path = raw.startsWith("file:") ? fileURLToPath(raw) : raw;
+    if (path === SELF) continue;
+    frames.push(path);
+  }
+  const authored = frames.find((p) => !LOADER_FRAME.test(p));
+  return dirname(authored ?? frames[0] ?? process.cwd());
+}
+var ALLOWED_TOP_LEVEL = ["type", "interface", "declare"];
+function assertOnlyDefaultExport(mask, path) {
+  let depth = 0;
+  let atStatementStart = true;
+  for (let i = 0; i < mask.length; i++) {
+    const ch = mask[i] ?? "";
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      continue;
+    }
+    if (depth === 0 && (ch === ";" || ch === "\n")) {
+      atStatementStart = true;
+      continue;
+    }
+    if (/\s/.test(ch) || depth > 0) continue;
+    if (!atStatementStart) continue;
+    atStatementStart = false;
+    const rest = mask.slice(i);
+    const word = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(rest)?.[0];
+    if (word === void 0 || ALLOWED_TOP_LEVEL.includes(word)) continue;
+    if (word === "export") {
+      if (/^export\s+(?:default\b|type\b|interface\b)/.test(rest)) continue;
+      throw new Error(
+        `${PREFIX}: ${path} exports something besides its default. Only the default export's BODY is sent to the engine, so a second export is undefined at runtime \u2014 the engine returns that failure as diagnostic text in the value slot rather than as an error. A lambda module is one \`export default\` function and nothing else: move it inside that function. (issue #221)`
+      );
+    }
+    if (word === "import") {
+      if (/^import\s+type\b/.test(rest)) continue;
+      throw new Error(
+        `${PREFIX}: ${path} imports a value at the top level, which the engine never resolves \u2014 only the default export's body is sent, so the import is undefined at runtime. Use \`import type\` for types, or reach a dependency through the PRELOADED globals, which need no specifier and are the only route that works on every instance: ${LAMBDA_MODULE_GLOBALS.join(", ")} (plus ${LAMBDA_GLOBALS.join(" / ")}, fetch, Buffer, TextEncoder). (issues #221, #265)`
+      );
+    }
+    const declared = /^(?:const|let|var|function|class|async)\s+([A-Za-z_$][A-Za-z0-9_$]*)/.exec(mask.slice(i))?.[1];
+    throw new Error(
+      `${PREFIX}: ${path} declares \`${declared ?? word}\` at the top level, and only the default export's BODY is sent to the engine \u2014 anything beside it is undefined at runtime, and the engine returns that failure as diagnostic text in the value slot rather than as an error. Move it inside the default-exported function. (issue #221)`
+    );
+  }
+}
+function functionExtent(mask) {
+  let depth = 0;
+  let seenBody = false;
+  for (let i = 0; i < mask.length; i++) {
+    const ch = mask[i] ?? "";
+    if (ch === "(" || ch === "[" || ch === "{") {
+      depth++;
+      if (ch === "{" && depth === 1) seenBody = true;
+      continue;
+    }
+    if (ch === ")" || ch === "]" || ch === "}") {
+      depth--;
+      if (depth === 0 && ch === "}" && seenBody) return i + 1;
+      continue;
+    }
+    if (depth === 0 && (ch === ";" || ch === "\n")) return i;
+  }
+  return mask.length;
+}
+function file(path, opts) {
+  const resolved = isAbsolute(path) ? path : resolve(callerDir(), path);
+  let source;
+  try {
+    source = readFileSync(resolved, "utf8");
+  } catch {
+    throw new Error(
+      `${PREFIX}: cannot read ${resolved} (resolved from ${JSON.stringify(path)}, relative to the calling module rather than the working directory). (issue #221)`
+    );
+  }
+  const mask = maskNonCode(source);
+  assertOnlyDefaultExport(mask, resolved);
+  const marker = /(^|[;}\n])\s*export\s+default\s+/.exec(mask);
+  if (marker === null) {
+    throw new Error(
+      `${PREFIX}: ${resolved} has no \`export default\`. A lambda module is one default-exported function whose first parameter destructures the bindings \u2014 \`export default ({ $this }: LambdaBindings<"map">) => \u2026\`. (issue #221)`
+    );
+  }
+  if (mask.slice(marker.index + marker[0].length).match(/(^|[;}\n])\s*export\s+default\s+/)) {
+    throw new Error(`${PREFIX}: ${resolved} has more than one \`export default\`.`);
+  }
+  const start = marker.index + marker[0].length;
+  const afterMask = mask.slice(start);
+  if (!/^\s*(?:async\s+)?(?:function\b|\(|[A-Za-z_$])/.test(afterMask)) {
+    throw new Error(
+      `${PREFIX}: ${resolved} default-exports something that is not a function. Export the lambda itself: \`export default ({ $this }: LambdaBindings<"map">) => \u2026\`. (issue #221)`
+    );
+  }
+  const end = start + functionExtent(afterMask);
+  return lambdaValue(extractFunctionBody(source.slice(start, end), PREFIX), opts, `${PREFIX}(${path})`);
+}
+var lam2 = { ...lam, file };
+export {
+  LAMBDA_BINDINGS,
+  LAMBDA_CODE_FILTERS,
+  LAMBDA_GLOBALS,
+  LAMBDA_MODULE_GLOBALS,
+  LAMBDA_STATEMENTS,
+  TEST_EXPECT_TYPES,
+  Xano,
+  actionCall,
+  actionPackageCall,
+  addon,
+  addonCall,
+  agent,
+  agentTrigger,
+  aiAgentRun,
+  and,
+  annotate,
+  apiCall,
+  apiGroup,
+  arrayMap,
+  arrayUnion,
+  assertLambdaBody,
+  auth,
+  bitwiseAnd,
+  bitwiseOr,
+  bitwiseXor,
+  c,
+  caught,
+  cloudJob,
+  cloudJobAwait,
+  cloudJobStatus,
+  cmp,
+  col,
+  comment,
+  compile,
+  conditional,
+  createAuthToken,
+  dbAdd,
+  dbAddOrEdit,
+  dbBulkAdd,
+  dbBulkDelete,
+  dbBulkPatch,
+  dbBulkUpdate,
+  dbDel,
+  dbDirectQuery,
+  dbEdit,
+  dbExternalQuery,
+  dbGet,
+  dbHas,
+  dbPatch,
+  dbQuery,
+  dbSchema,
+  dbTransaction,
+  dbTruncate,
+  debugLog,
+  defineFunction,
+  die,
+  emit,
+  emitBundle,
+  env,
+  errorTrigger,
+  expect,
+  expectToThrow,
+  exportBundleJson,
+  expr,
+  f,
+  fileUrl,
+  filter,
+  fl,
+  forLoop,
+  foreachBreak,
+  foreachContinue,
+  foreachLoop,
+  foreachRemove,
+  functionCall,
+  functionRun,
+  getRawInput,
+  group,
+  ignored,
+  inp,
+  input,
+  ipLookup,
+  lam2 as lam,
+  loadDefault,
+  mathAdd,
+  mathDiv,
+  mathMul,
+  mathSub,
+  mcpServer,
+  mcpServerTrigger,
+  microservice,
+  middleware,
+  middlewareCall,
+  mixed,
+  obj,
+  objectEntries,
+  objectKeys,
+  objectValues,
+  or,
+  out,
+  parseArgs,
+  postProcess,
+  query,
+  readLockFile,
+  realtimeChannel,
+  realtimeChannelTrigger,
+  realtimeEvent,
+  realtimeMessage,
+  realtimeServer,
+  realtimeServerTrigger,
+  realtimeTrigger,
+  ref,
+  resetLockOverrides,
+  resp,
+  returnValue,
+  run,
+  s,
+  seedFile,
+  seedLockOverrides,
+  setVar,
+  setting,
+  statements,
+  switchCase,
+  switchStatement,
+  sys,
+  table,
+  tableTrigger,
+  task,
+  taskCall,
+  test,
+  textAppend,
+  textPrepend,
+  toSearchParams,
+  tool,
+  toolCall,
+  toolset,
+  triggerCall,
+  tryCatch,
+  updateVar,
+  whileLoop,
+  withFilters,
+  workflowTest,
+  workflowTestCall,
+  workspace,
+  workspaceConfig,
+  workspaceTrigger,
+  writeArtifact,
+  writeBundle,
+  writeLockFile
+};
+//# sourceMappingURL=node.js.map

package/dist/profile-command-SWJ3SPKR.js

@@ -0,0 +1,77 @@
+import {
+  isMachineOutput,
+  writeJson
+} from "./chunk-NUQCEOKA.js";
+import {
+  fetchOrExplain,
+  httpFailure
+} from "./chunk-3IGNIP6R.js";
+import {
+  getAccessToken
+} from "./chunk-C56BC2FY.js";
+import "./chunk-7REDODS2.js";
+import {
+  formatFields,
+  stdoutStyle
+} from "./chunk-EZG76F7R.js";
+import "./chunk-GNPVYOPB.js";
+
+// src/emit/profile-command.ts
+var PROFILE_TIMEOUT_MS = 3e4;
+function asString(v) {
+  return typeof v === "string" && v !== "" ? v : void 0;
+}
+async function fetchProfile(args) {
+  const { access_token, instance } = await getAccessToken(args);
+  const url = new URL("/api:meta/auth/me", instance);
+  const res = await fetchOrExplain(
+    url.href,
+    {
+      headers: { Authorization: `Bearer ${access_token}` },
+      signal: AbortSignal.timeout(PROFILE_TIMEOUT_MS)
+    },
+    "profile me",
+    PROFILE_TIMEOUT_MS
+  );
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(httpFailure("profile me", res, text));
+  }
+  let data = {};
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new Error(`profile me: could not parse the ${url.pathname} response as JSON:
+${text}`);
+  }
+  return {
+    instance,
+    user: {
+      id: typeof data.id === "number" ? data.id : void 0,
+      name: asString(data.name),
+      email: asString(data.email)
+    }
+  };
+}
+function prettyProfile(p) {
+  const s = stdoutStyle();
+  const who = [p.user.name, p.user.email && `<${p.user.email}>`].filter(Boolean).join(" ");
+  const id = p.user.id !== void 0 ? ` ${s.dim(`\xB7 id ${p.user.id}`)}` : "";
+  return "\n" + formatFields([
+    ["Signed in", who !== "" ? `${who}${id}` : s.dim("(unknown user)")],
+    ["Instance", s.bold(s.cyan(p.instance))]
+  ]);
+}
+async function runProfileCommand(args) {
+  const profile = await fetchProfile(args);
+  if (isMachineOutput(args)) {
+    writeJson(profile);
+  } else {
+    process.stdout.write(prettyProfile(profile));
+  }
+}
+export {
+  fetchProfile,
+  runProfileCommand
+};
+//# sourceMappingURL=profile-command-SWJ3SPKR.js.map