@beachside/freestyle 0.0.0-stage → 0.11.0

package/dist/index.js

@@ -0,0 +1,2490 @@
+// src/adapter.ts
+import { createHash } from "node:crypto";
+import { FreestyleApiError as FreestyleApiError2 } from "freestyle";
+import { z as z4 } from "zod";
+import {
+  AdapterCheckpointError,
+  AdapterError as AdapterError6,
+  AdapterFilesystemError as AdapterFilesystemError2,
+  assertResourceScope,
+  DEFAULT_LIFETIME_SECONDS,
+  defineAdapter,
+  listedLabels,
+  listedTime,
+  MAX_DIRECTORY_ENTRIES,
+  Preserve,
+  PreserveSchema,
+  PreviewPort,
+  resolveSnapshot,
+  ResourceMinimums,
+  sandboxReference,
+  smallestSize,
+  unknownSandboxFacts
+} from "@beachside/adapter";
+
+// src/exec.ts
+import { AdapterError } from "@beachside/adapter";
+var EXEC_RECORD = "BEACHSIDE-EXEC-1";
+var INLINE_BYTES = 32 * 1024;
+var EnvKey = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function quote(word) {
+  if (word.includes("\x00"))
+    throw new AdapterError("INVALID_ARGUMENT", "Arguments cannot contain NUL");
+  return `'${word.replaceAll("'", `'\\''`)}'`;
+}
+var ENV_FILE = "/etc/beachside.env";
+function checkedEnvKey(key) {
+  if (!EnvKey.test(key))
+    throw new AdapterError("INVALID_ARGUMENT", "Environment variable names must be POSIX names");
+  return key;
+}
+function envFile(env, attempt) {
+  const lines = Object.entries(env).map(([key, value]) => `export ${checkedEnvKey(key)}=${quote(value)}`);
+  return new TextEncoder().encode([envMarker(attempt), ...lines, ""].join(`
+`));
+}
+function envMarker(attempt) {
+  return `# beachside ${attempt}`;
+}
+function checkEnv(env) {
+  for (const [key, value] of Object.entries(env ?? {}))
+    quote(`${checkedEnvKey(key)}=${value}`);
+}
+function commandLine(input) {
+  if (input.command.kind === "argv" && input.command.argv.length === 0)
+    throw new AdapterError("INVALID_ARGUMENT", "argv must name a program");
+  const env = Object.entries(input.env ?? {}).map(([key, value]) => quote(`${checkedEnvKey(key)}=${value}`));
+  const program = input.command.kind === "argv" ? input.command.argv.map(quote).join(" ") : `/bin/sh -c ${quote(input.command.script)}`;
+  const exports = env.length ? `export ${env.join(" ")}; ` : "";
+  const run = `{ if [ -r ${ENV_FILE} ]; then . ${ENV_FILE}; fi; ${exports}exec ${program}; }`;
+  return input.cwd === undefined ? run : `cd -- ${quote(input.cwd)} && ${run}`;
+}
+function wrapperScript(input) {
+  const body = commandLine(input);
+  const stdin = input.stdin ? "" : " </dev/null";
+  const bound = Math.max(0, Math.floor(input.maxBytes));
+  return [
+    "beachside_d=$(mktemp -d /tmp/beachside-exec.XXXXXXXX) || exit 97",
+    `(while [ ! -e "$beachside_d/done" ]; do for beachside_s in stdout stderr; do beachside_z=$(($(wc -c <"$beachside_d/$beachside_s.raw" 2>/dev/null || echo 0))); if [ "$beachside_z" -gt ${bound} ]; then fallocate -p -o ${bound} -l $((beachside_z - ${bound})) "$beachside_d/$beachside_s.raw" 2>/dev/null; fi; done; sleep 0.2; done) </dev/null >/dev/null 2>&1 &`,
+    "beachside_w=$!",
+    `(${body})${stdin} >"$beachside_d/stdout.raw" 2>"$beachside_d/stderr.raw"`,
+    "beachside_c=$?",
+    `: >"$beachside_d/done"; kill "$beachside_w" 2>/dev/null; wait "$beachside_w" 2>/dev/null; rm -f "$beachside_d/done"`,
+    `beachside_ol=$(($(wc -c <"$beachside_d/stdout.raw"))); beachside_el=$(($(wc -c <"$beachside_d/stderr.raw")))`,
+    `beachside_ok=$((beachside_ol < ${bound} ? beachside_ol : ${bound}))`,
+    `head -c "$beachside_ok" "$beachside_d/stdout.raw" >"$beachside_d/stdout"; head -c $((${bound} - beachside_ok)) "$beachside_d/stderr.raw" >"$beachside_d/stderr"`,
+    `rm -f "$beachside_d/stdout.raw" "$beachside_d/stderr.raw"`,
+    `if [ $(($(wc -c <"$beachside_d/stdout") + $(wc -c <"$beachside_d/stderr"))) -le ${INLINE_BYTES} ]; then`,
+    `printf '${EXEC_RECORD} inline %s %s %s\\n' "$beachside_c" "$beachside_ol" "$beachside_el"`,
+    `base64 <"$beachside_d/stdout" | tr -d '\\n'; printf '\\n'`,
+    `base64 <"$beachside_d/stderr" | tr -d '\\n'; printf '\\n'`,
+    `rm -rf "$beachside_d"`,
+    "else",
+    `printf '${EXEC_RECORD} files %s %s %s %s\\n' "$beachside_c" "$beachside_ol" "$beachside_el" "$beachside_d"`,
+    "fi"
+  ].join(`
+`);
+}
+var Inline = new RegExp(`^${EXEC_RECORD} inline (\\d{1,3}) (\\d{1,15}) (\\d{1,15})\\n([A-Za-z0-9+/]*={0,2})\\n([A-Za-z0-9+/]*={0,2})\\n$`);
+var Files = new RegExp(`^${EXEC_RECORD} files (\\d{1,3}) (\\d{1,15}) (\\d{1,15}) (/tmp/beachside-exec\\.[A-Za-z0-9]{8})\\n$`);
+function parseWrapper(stdout) {
+  const files = Files.exec(stdout);
+  if (files) {
+    const [, code2, outLength2, errLength2, directory = ""] = files;
+    return {
+      exitCode: Number(code2),
+      stdoutLength: Number(outLength2),
+      stderrLength: Number(errLength2),
+      directory
+    };
+  }
+  const match = Inline.exec(stdout);
+  if (!match)
+    return null;
+  const [, code, outLength, errLength, out = "", err = ""] = match;
+  const stdoutBytes = Buffer.from(out, "base64");
+  const stderrBytes = Buffer.from(err, "base64");
+  const lengths = [Number(outLength), Number(errLength)];
+  if (stdoutBytes.length > lengths[0] || stderrBytes.length > lengths[1] || stdoutBytes.toString("base64") !== out || stderrBytes.toString("base64") !== err)
+    return null;
+  return {
+    exitCode: Number(code),
+    stdout: new Uint8Array(stdoutBytes),
+    stderr: new Uint8Array(stderrBytes),
+    truncated: stdoutBytes.length < lengths[0] || stderrBytes.length < lengths[1]
+  };
+}
+function filesResult(files, stdout, stderr, maxBytes) {
+  const bound = Math.max(0, Math.floor(maxBytes));
+  const outExpected = Math.min(files.stdoutLength, bound);
+  const errExpected = Math.min(files.stderrLength, bound - outExpected);
+  if (stdout.byteLength > outExpected || stderr.byteLength > errExpected)
+    return null;
+  return {
+    complete: stdout.byteLength === outExpected && stderr.byteLength === errExpected,
+    result: {
+      exitCode: files.exitCode,
+      stdout,
+      stderr,
+      truncated: stdout.byteLength < files.stdoutLength || stderr.byteLength < files.stderrLength
+    }
+  };
+}
+
+// src/filesystem.ts
+import { randomUUID } from "node:crypto";
+import { posix } from "node:path";
+import {
+  AdapterError as AdapterError2,
+  AdapterFilesystemError
+} from "@beachside/adapter";
+import { z } from "zod";
+var FILESYSTEM_HELPER = String.raw`
+import os,sys,json,stat,errno,ctypes,tempfile,shutil
+op,p,q,flag,stage=sys.argv[1:6]
+published=False
+created=False
+overwrite=flag=='true'
+def kind(s):
+ return 'symlink' if stat.S_ISLNK(s.st_mode) else 'file' if stat.S_ISREG(s.st_mode) else 'directory' if stat.S_ISDIR(s.st_mode) else 'unknown'
+def rename(a,b):
+ if overwrite: os.replace(a,b)
+ else:
+  libc=ctypes.CDLL(None,use_errno=True)
+  fn=getattr(libc,'renameat2',None)
+  if fn is None: raise OSError(errno.ENOSYS,'renameat2 unavailable')
+  if fn(-100,os.fsencode(a),-100,os.fsencode(b),1)!=0:
+   e=ctypes.get_errno();raise OSError(e,os.strerror(e))
+def publish(a,b):
+ global published
+ if overwrite and os.path.lexists(b) and not stat.S_ISREG(os.lstat(b).st_mode): raise OSError(errno.EINVAL,'regular destination required')
+ if overwrite: os.replace(a,b);published=True
+ else:
+  os.link(a,b,follow_symlinks=False);published=True;os.unlink(a)
+def parents(path):
+ os.makedirs(os.path.dirname(path) or '/',exist_ok=True)
+def regular(path):
+ s=os.lstat(path)
+ if not stat.S_ISREG(s.st_mode): raise OSError(errno.EINVAL,'regular file required')
+try:
+ result={}
+ if op=='list':
+  entries=[]; names=0
+  with os.scandir(p) as it:
+   for e in it:
+    names+=len(e.name.encode('utf-8'))
+    if len(entries)>=1024 or names>65536: raise OSError(errno.EFBIG,'directory bound exceeded')
+    try: t=kind(e.stat(follow_symlinks=False))
+    except FileNotFoundError: t='unknown'
+    entries.append({'name':e.name,'type':t})
+  entries.sort(key=lambda e:e['name'])
+  result={'entries':entries,'completeness':'complete'}
+ elif op=='stat':
+  s=os.stat(p) if overwrite else os.lstat(p)
+  result={'type':kind(s),'sizeBytes':s.st_size,'modifiedAt':s.st_mtime,'mode':stat.S_IMODE(s.st_mode)}
+ elif op=='mkdir':
+  try:
+   if overwrite: os.makedirs(p,exist_ok=True)
+   else: os.mkdir(p)
+  except FileExistsError:
+   if not os.path.isdir(p): raise OSError(errno.EINVAL,'existing entry is not a directory')
+ elif op=='remove':
+  try:
+   s=os.lstat(p)
+   if stat.S_ISDIR(s.st_mode):
+    if overwrite: shutil.rmtree(p)
+    else: os.rmdir(p)
+   else: os.unlink(p)
+  except FileNotFoundError: pass
+ elif op=='exists':
+  try: os.lstat(p);result={'exists':True}
+  except FileNotFoundError: result={'exists':False}
+ elif op=='append':
+  fd=os.open(p,os.O_WRONLY|os.O_NOFOLLOW)
+  with os.fdopen(fd,'r+b') as f:
+   f.seek(0,2)
+   if f.tell()!=int(q): raise OSError(errno.EINVAL,'unexpected staging size')
+   data=sys.stdin.buffer.read(1048577)
+   if len(data)>1048576: raise OSError(errno.EFBIG,'chunk bound exceeded')
+   f.write(data)
+  result={'bytesWritten':len(data)}
+ elif op=='reserve':
+  parents(p);fd=os.open(p,os.O_CREAT|os.O_EXCL|os.O_WRONLY,0o600);os.close(fd)
+ elif op=='publish':
+  regular(p)
+  try: publish(p,q);published=True
+  finally:
+   # A refused publish leaves nothing behind: the staged bytes are this attempt's own.
+   if not published and os.path.lexists(p): os.unlink(p)
+ elif op=='copy':
+  regular(p)
+  if overwrite and os.path.lexists(q) and not stat.S_ISREG(os.lstat(q).st_mode): raise OSError(errno.EINVAL,'regular destination required')
+  parents(stage);fd=os.open(stage,os.O_CREAT|os.O_EXCL|os.O_WRONLY,0o600);created=True
+  try:
+   src=os.open(p,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK)
+   with os.fdopen(src,'rb') as inp,os.fdopen(fd,'wb') as out:
+    if not stat.S_ISREG(os.fstat(inp.fileno()).st_mode): raise OSError(errno.EINVAL,'regular file required')
+    shutil.copyfileobj(inp,out,65536)
+   publish(stage,q);published=True
+  finally:
+   if created and os.path.lexists(stage): os.unlink(stage)
+ elif op=='move':
+  os.lstat(p);rename(p,q)
+ print(json.dumps({'ok':True,'value':result},ensure_ascii=True))
+except OSError as e:
+ code='NOT_FOUND' if e.errno==errno.ENOENT else 'CONFLICT' if e.errno in (errno.EEXIST,errno.ENOTEMPTY) else 'FORBIDDEN' if e.errno in (errno.EACCES,errno.EPERM) else 'CAPACITY' if e.errno in (errno.EFBIG,errno.ENOSPC) else 'UNSUPPORTED' if e.errno in (errno.EXDEV,errno.ENOSYS,errno.EOPNOTSUPP) else 'INVALID_ARGUMENT'
+ print(json.dumps({'ok':False,'code':code,'effect':'applied' if published else 'possible' if (created and os.path.lexists(stage)) or (op in ('mkdir','remove') and overwrite) else 'none','temporaryPaths':[stage] if created and os.path.lexists(stage) else []}))
+`;
+var STAGE_CHUNK_BYTES = 1048576;
+var READ_CHUNK_BYTES = 1048576;
+var Receipt = z.discriminatedUnion("ok", [
+  z.object({ ok: z.literal(true), value: z.json() }),
+  z.object({
+    ok: z.literal(false),
+    code: z.enum([
+      "NOT_FOUND",
+      "CONFLICT",
+      "FORBIDDEN",
+      "CAPACITY",
+      "UNSUPPORTED",
+      "INVALID_ARGUMENT"
+    ]),
+    effect: z.enum(["none", "possible", "applied"]),
+    temporaryPaths: z.array(z.string())
+  })
+]);
+var reads = new Set(["stat", "list", "exists"]);
+async function rangeResult(response, offset, length) {
+  const header = response.headers.get("content-range") ?? "";
+  if (response.status === 416) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    if (!header)
+      return { bytes: new Uint8Array, total: offset };
+    const match2 = /^bytes \*\/(\d{1,15})$/.exec(header);
+    const total2 = match2 ? Number(match2[1]) : undefined;
+    return total2 === offset ? { bytes: new Uint8Array, total: total2 } : null;
+  }
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (response.status === 200)
+    return offset === 0 && bytes.length <= length ? { bytes, total: bytes.length } : null;
+  if (response.status !== 206 || bytes.length > length)
+    return null;
+  if (!header)
+    return { bytes, total: undefined };
+  const match = /^bytes (\d{1,15})-(\d{1,15})\/(\d{1,15}|\*)$/.exec(header);
+  if (!match)
+    return null;
+  const [, start, end, size] = match;
+  const total = size === "*" ? undefined : Number(size);
+  if (Number(start) !== offset || Number(end) - Number(start) + 1 !== bytes.length || total !== undefined && Number(end) >= total)
+    return null;
+  return { bytes, total };
+}
+function filesystem(run, readRange) {
+  const helper = async (op, path, destination, flag, ctx, stage = "", stdin) => {
+    ctx.signal.throwIfAborted();
+    const command = ["python3", "-c", FILESYSTEM_HELPER, op, path, destination, String(flag), stage].map(quote).join(" ");
+    const uncertain = () => new AdapterFilesystemError("UNAVAILABLE", "Freestyle filesystem response was not confirmed; do not replay", {
+      effect: "possible",
+      source: path,
+      destination: destination || path,
+      temporaryPaths: stage ? [stage] : []
+    });
+    let receipt;
+    try {
+      const stdout = await run(command, { ...ctx, deadline: Math.min(ctx.deadline, Date.now() + 60000) }, stdin);
+      receipt = Receipt.parse(JSON.parse(stdout));
+    } catch (error) {
+      if (ctx.signal.aborted)
+        throw ctx.signal.reason;
+      if (!reads.has(op))
+        throw uncertain();
+      if (error instanceof AdapterError2)
+        throw error;
+      throw new AdapterError2("UNAVAILABLE", "Freestyle filesystem helper failed; Python 3 is required in the VM");
+    }
+    if (!receipt.ok)
+      throw new AdapterFilesystemError(receipt.code, "Freestyle filesystem request rejected", {
+        effect: receipt.effect,
+        source: path,
+        destination: destination || path,
+        temporaryPaths: receipt.temporaryPaths
+      });
+    return receipt.value;
+  };
+  const staging = (path) => posix.join(posix.dirname(path), `.beachside-${randomUUID()}`);
+  const write = async (path, bytes, overwrite, ctx) => {
+    const stage = staging(path);
+    let count = 0;
+    ctx.retain?.({ temporaryPaths: [stage] });
+    try {
+      await helper("reserve", stage, "", false, ctx);
+      for await (const input of bytes)
+        for (let offset = 0;offset < input.length; offset += STAGE_CHUNK_BYTES) {
+          ctx.signal.throwIfAborted();
+          const chunk = input.subarray(offset, offset + STAGE_CHUNK_BYTES);
+          const ack = z.object({ bytesWritten: z.number().int() }).parse(await helper("append", stage, String(count), false, { ...ctx, deadline: Date.now() + 60000 }, "", chunk));
+          if (ack.bytesWritten !== chunk.length)
+            throw new AdapterFilesystemError("UNAVAILABLE", "Freestyle staging byte count differs", {
+              effect: "possible",
+              source: stage,
+              destination: path,
+              temporaryPaths: [stage]
+            });
+          count += chunk.length;
+          ctx.retain?.({ temporaryPaths: [stage], bytesTransferred: count });
+        }
+      await helper("publish", stage, path, overwrite, { ...ctx, deadline: Date.now() + 60000 });
+      ctx.retain?.({ effect: "applied", temporaryPaths: [], bytesTransferred: count });
+      return { bytesWritten: count };
+    } catch (error) {
+      if (error instanceof AdapterFilesystemError) {
+        if (error.details.effect === "applied")
+          ctx.retain?.({ effect: "applied", temporaryPaths: [stage], bytesTransferred: count });
+        throw new AdapterFilesystemError(error.code, error.message, {
+          ...error.details,
+          source: stage,
+          destination: path,
+          temporaryPaths: [stage],
+          bytesTransferred: count
+        });
+      }
+      throw error;
+    }
+  };
+  return {
+    helper,
+    write,
+    async transfer(op, source, destination, overwrite, ctx) {
+      const stage = op === "copy" ? staging(destination) : "";
+      ctx.retain?.({ temporaryPaths: stage ? [stage] : [] });
+      await helper(op, source, destination, overwrite, ctx, stage);
+      ctx.retain?.({ effect: "applied", temporaryPaths: [] });
+      return { acknowledged: true };
+    },
+    read(path, ctx) {
+      let offset = 0;
+      const cancellation = new AbortController;
+      const signal = AbortSignal.any([ctx.signal, cancellation.signal]);
+      return new ReadableStream({
+        cancel() {
+          cancellation.abort();
+        },
+        async pull(controller) {
+          try {
+            const { bytes, total } = await readRange(path, offset, READ_CHUNK_BYTES, {
+              signal,
+              deadline: Date.now() + 60000
+            });
+            if (bytes.length > READ_CHUNK_BYTES)
+              throw new AdapterError2("UNAVAILABLE", "Freestyle file range is malformed");
+            offset += bytes.length;
+            if (bytes.length)
+              controller.enqueue(bytes);
+            if (total === undefined ? bytes.length < READ_CHUNK_BYTES : offset >= total)
+              controller.close();
+            else if (!bytes.length)
+              throw new AdapterError2("UNAVAILABLE", "Freestyle file range ended early");
+          } catch (error) {
+            controller.error(error);
+          }
+        }
+      }, { highWaterMark: 0 });
+    }
+  };
+}
+var Directory = z.object({
+  entries: z.array(z.object({ name: z.string(), type: z.enum(["file", "directory", "symlink", "unknown"]) })),
+  completeness: z.literal("complete")
+});
+function directoryValue(value) {
+  const parsed = Directory.safeParse(value);
+  if (!parsed.success)
+    throw new AdapterError2("UNAVAILABLE", "Freestyle directory response is invalid");
+  return { ...parsed.data, observedAt: new Date().toISOString() };
+}
+function statValue(value) {
+  const result = z.object({
+    type: z.enum(["file", "directory", "symlink", "unknown"]),
+    sizeBytes: z.number().int().nonnegative().safe(),
+    modifiedAt: z.number(),
+    mode: z.number().int().nonnegative()
+  }).safeParse(value);
+  if (!result.success || Math.abs(result.data.modifiedAt * 1000) > 8640000000000000)
+    throw new AdapterError2("UNAVAILABLE", "Freestyle metadata response is invalid");
+  return { ...result.data, modifiedAt: new Date(result.data.modifiedAt * 1000).toISOString() };
+}
+var Exists = z.object({ exists: z.boolean() });
+
+// src/process.ts
+import {
+  AdapterError as AdapterError3
+} from "@beachside/adapter";
+import { setImmediate as yieldOutput } from "node:timers/promises";
+import { z as z2 } from "zod";
+var PROCESS_RECORD = "BEACHSIDE-PROC-1";
+var POLL_RECORD = "BEACHSIDE-POLL-1";
+var POLL_BYTES = 256 * 1024;
+var DELIVERY_BYTES = 16384;
+var MAX_WRITE_BYTES = 1048576;
+var POLL_FAILURES = 5;
+var Directory2 = z2.string().regex(/^\/tmp\/beachside-proc\.[A-Za-z0-9]{8}$/);
+var ProcessReference = z2.strictObject({
+  version: z2.literal(1),
+  kind: z2.literal("freestyle-job"),
+  sandbox: z2.string().min(1).max(128),
+  directory: Directory2,
+  stdin: z2.enum(["closed", "pipe"])
+});
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((accept, fail) => {
+    resolve = accept;
+    reject = fail;
+  });
+  promise.catch(() => {
+    return;
+  });
+  return { promise, resolve, reject };
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", stop);
+      resolve();
+    }, ms);
+    const stop = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    signal.addEventListener("abort", stop, { once: true });
+  });
+}
+function launcherScript(input) {
+  const piped = input.stdin === "pipe";
+  const command = [
+    'echo $$ >"$1/pid"',
+    `exec <${piped ? '"$1/in"' : "/dev/null"} >"$1/out" 2>"$1/err"`,
+    commandLine(input)
+  ].join("; ");
+  const job = [
+    `setsid -w sh -c ${quote(command)} sh "$1"`,
+    'echo $? >"$1/exit.tmp"',
+    ...piped ? ['[ -s "$1/holder" ] && kill "$(cat "$1/holder")" 2>/dev/null; : >"$1/holder"'] : [],
+    'mv "$1/exit.tmp" "$1/exit"'
+  ].join("; ");
+  const lines = [
+    "beachside_d=$(mktemp -d /tmp/beachside-proc.XXXXXXXX) || exit 97",
+    ': >"$beachside_d/out"; : >"$beachside_d/err"'
+  ];
+  if (piped)
+    lines.push('mkfifo "$beachside_d/in" || exit 97', `setsid -f sh -c ${quote('echo $$ >"$1/holder"; exec sleep 2147483647 >"$1/in"')} sh "$beachside_d" </dev/null >/dev/null 2>&1`);
+  lines.push(`setsid -f sh -c ${quote(job)} sh "$beachside_d" </dev/null >/dev/null 2>&1`, "beachside_i=0", 'while [ ! -s "$beachside_d/pid" ] && [ "$beachside_i" -lt 200 ]; do sleep 0.05; beachside_i=$((beachside_i + 1)); done', '[ -s "$beachside_d/pid" ] || exit 98', `printf '${PROCESS_RECORD} %s\\n' "$beachside_d"`);
+  return lines.join(`
+`);
+}
+function pollScript(directory, offsets) {
+  const dir = quote(directory);
+  return [
+    `cd ${dir} 2>/dev/null || { printf '${POLL_RECORD} gone\\n'; exit 0; }`,
+    "beachside_x=-; if [ -f exit ]; then beachside_x=$(cat exit); fi",
+    "beachside_o=$(($(wc -c <out))); beachside_e=$(($(wc -c <err)))",
+    `printf '${POLL_RECORD} %s %s %s\\n' "$beachside_x" "$beachside_o" "$beachside_e"`,
+    `tail -c +${offsets.stdout + 1} out | head -c ${POLL_BYTES} | base64 | tr -d '\\n'; printf '\\n'`,
+    `tail -c +${offsets.stderr + 1} err | head -c ${POLL_BYTES} | base64 | tr -d '\\n'; printf '\\n'`
+  ].join(`
+`);
+}
+var Base64 = /^[A-Za-z0-9+/]*={0,2}$/;
+var PollLine = new RegExp(`^${POLL_RECORD} (-|\\d{1,3}) (\\d{1,15}) (\\d{1,15})$`);
+function parsePoll(text) {
+  if (text === `${POLL_RECORD} gone
+`)
+    return { gone: true };
+  const [header = "", out = "", err = "", rest] = text.split(`
+`);
+  const match = PollLine.exec(header);
+  if (!match || rest !== "" || !Base64.test(out) || !Base64.test(err))
+    return null;
+  const stdout = Buffer.from(out, "base64");
+  const stderr = Buffer.from(err, "base64");
+  if (stdout.toString("base64") !== out || stderr.toString("base64") !== err)
+    return null;
+  return {
+    gone: false,
+    exit: match[1] === "-" ? undefined : Number(match[1]),
+    sizes: { stdout: Number(match[2]), stderr: Number(match[3]) },
+    stdout: new Uint8Array(stdout),
+    stderr: new Uint8Array(stderr)
+  };
+}
+var signalNames = { SIGTERM: "TERM", SIGKILL: "KILL" };
+async function observeJob(options, reference, input, ctx) {
+  if (input.format === "bytes" && !ctx.onOutputBytes)
+    throw new AdapterError3("UNSUPPORTED", "Freestyle binary output requires a byte consumer hook");
+  const { run } = options;
+  const dir = quote(reference.directory);
+  const controller = new AbortController;
+  const exited = deferred();
+  const output = deferred();
+  const capture = input.capture ? deferred() : undefined;
+  const captureLimit = input.capture?.maxBytes ?? 0;
+  const captured = { stdout: new Array, stderr: new Array };
+  let capturedBytes = 0;
+  let truncated = false;
+  const decoders = { stdout: new TextDecoder, stderr: new TextDecoder };
+  const offsets = { stdout: 0, stderr: 0 };
+  let confirmedExit;
+  let outputDetached = false;
+  let detached = false;
+  const fail = () => new AdapterError3("UNAVAILABLE", "Freestyle process observation failed");
+  const request = () => ({
+    signal: controller.signal,
+    deadline: Date.now() + options.requestSeconds * 1000
+  });
+  const poll = async (context) => {
+    const parsed = parsePoll(await run(pollScript(reference.directory, offsets), context));
+    if (!parsed)
+      throw fail();
+    return parsed;
+  };
+  if (input.fromEnd) {
+    const first = await poll({ signal: ctx.signal, deadline: ctx.deadline });
+    if (first.gone)
+      throw new AdapterError3("NOT_FOUND", "Freestyle process is absent");
+    offsets.stdout = first.sizes.stdout;
+    offsets.stderr = first.sizes.stderr;
+  }
+  const deliver = async (stream, bytes) => {
+    for (let index = 0;index < bytes.length; index += DELIVERY_BYTES) {
+      deliverSegment(stream, bytes.subarray(index, index + DELIVERY_BYTES));
+      await yieldOutput();
+    }
+  };
+  const deliverSegment = (stream, bytes) => {
+    if (!bytes.length)
+      return;
+    if (capture) {
+      const take = Math.min(bytes.length, captureLimit - capturedBytes);
+      if (take > 0)
+        captured[stream].push(bytes.slice(0, take));
+      capturedBytes += take;
+      if (take < bytes.length)
+        truncated = true;
+    }
+    if (outputDetached || detached)
+      return;
+    try {
+      if (input.format === "bytes")
+        ctx.onOutputBytes({ stream, bytes });
+      else {
+        const text = decoders[stream].decode(bytes, { stream: true });
+        if (text)
+          ctx.onOutput({ stream, text });
+      }
+    } catch (error) {
+      outputDetached = true;
+      output.reject(error instanceof Error ? error : fail());
+    }
+  };
+  async function observe() {
+    let failures = 0;
+    while (!controller.signal.aborted) {
+      let result;
+      if (await options.held?.()) {
+        await sleep(options.pollMs, controller.signal);
+        continue;
+      }
+      try {
+        result = await poll(request());
+        failures = 0;
+      } catch (error) {
+        if (controller.signal.aborted)
+          return;
+        if (++failures >= POLL_FAILURES)
+          throw error;
+        await sleep(options.pollMs, controller.signal);
+        continue;
+      }
+      if (result.gone)
+        throw fail();
+      await deliver("stdout", result.stdout);
+      await deliver("stderr", result.stderr);
+      offsets.stdout += result.stdout.length;
+      offsets.stderr += result.stderr.length;
+      const drained = offsets.stdout >= result.sizes.stdout && offsets.stderr >= result.sizes.stderr;
+      if (result.exit !== undefined && drained) {
+        confirmedExit = { exitCode: result.exit };
+        if (input.format === "text" && !outputDetached && !detached)
+          for (const stream of ["stdout", "stderr"]) {
+            const text = decoders[stream].decode();
+            if (text)
+              ctx.onOutput({ stream, text });
+          }
+        exited.resolve(confirmedExit);
+        capture?.resolve({
+          exitCode: confirmedExit.exitCode,
+          stdout: new Uint8Array(Buffer.concat(captured.stdout)),
+          stderr: new Uint8Array(Buffer.concat(captured.stderr)),
+          truncated
+        });
+        output.resolve();
+        return;
+      }
+      if (!drained)
+        continue;
+      await sleep(options.pollMs, controller.signal);
+    }
+  }
+  observe().catch(() => {
+    return;
+  }).then(() => {
+    if (confirmedExit)
+      return;
+    const error = fail();
+    exited.reject(error);
+    output.reject(error);
+    capture?.reject(error);
+  });
+  const control = async (script, context, stdin) => {
+    if (detached)
+      throw fail();
+    if (await options.held?.())
+      throw new AdapterError3("CONFLICT", "Freestyle VM is paused; resume it before controlling the process");
+    return run(`cd ${dir} 2>/dev/null || { echo gone; exit 0; }
+${script}`, context, stdin);
+  };
+  async function sendSignal(signal, context) {
+    const name = signalNames[signal];
+    const answer = await control(`if [ -f exit ] || [ ! -s pid ]; then echo gone; elif kill -${name} "-$(cat pid)" 2>/dev/null; then echo ok; else echo gone; fi`, context);
+    return { status: answer.trim() === "ok" ? "requested" : "not-found" };
+  }
+  async function disconnect() {
+    if (detached)
+      return;
+    detached = true;
+    controller.abort();
+    if (!confirmedExit)
+      exited.reject(fail());
+    output.reject(fail());
+    capture?.reject(fail());
+  }
+  return {
+    reference,
+    signal: sendSignal,
+    terminate: (context) => sendSignal("SIGKILL", context),
+    disconnect,
+    detach: disconnect,
+    async detachOutput() {
+      outputDetached = true;
+      output.reject(fail());
+    },
+    get confirmedExit() {
+      return confirmedExit;
+    },
+    outputDone: output.promise,
+    capture: capture?.promise,
+    wait: () => exited.promise,
+    async status(context) {
+      const observedAt = new Date().toISOString();
+      if (confirmedExit)
+        return { state: "exited", exit: confirmedExit, observedAt };
+      const answer = (await control('if [ -f exit ]; then printf "exit %s\\n" "$(cat exit)"; elif [ -s pid ] && kill -0 "-$(cat pid)" 2>/dev/null; then echo running; else echo unknown; fi', context)).trim();
+      const code = /^exit (\d{1,3})$/.exec(answer);
+      if (code)
+        return { state: "exited", exit: { exitCode: Number(code[1]) }, observedAt };
+      return { state: answer === "running" ? "running" : "unknown", observedAt };
+    },
+    async write(bytes, context) {
+      if (reference.stdin !== "pipe")
+        throw new AdapterError3("UNSUPPORTED", "This Freestyle process has closed stdin");
+      for (let index = 0;index < bytes.length; index += MAX_WRITE_BYTES) {
+        const answer = (await control("if [ -f exit ] || [ ! -s holder ]; then echo gone; else timeout 10 sh -c 'cat >>in'; beachside_s=$?; if [ $beachside_s = 0 ]; then echo ok; elif [ $beachside_s = 124 ]; then echo timeout; else echo failed; fi; fi", context, bytes.subarray(index, index + MAX_WRITE_BYTES))).trim();
+        if (answer === "gone")
+          throw new AdapterError3("NOT_FOUND", "Freestyle process stdin is closed or absent");
+        if (answer === "timeout")
+          throw new AdapterError3("TIMEOUT", "Freestyle process did not read its stdin in time; part of the input may have been written");
+        if (answer !== "ok")
+          throw new AdapterError3("UNAVAILABLE", "Freestyle process stdin write failed; part of the input may have been written");
+      }
+    },
+    async closeStdin(context) {
+      if (reference.stdin !== "pipe")
+        throw new AdapterError3("UNSUPPORTED", "This Freestyle process has closed stdin");
+      const answer = await control('if [ -s holder ] && kill "$(cat holder)" 2>/dev/null; then : >holder; echo ok; elif [ -f holder ]; then echo ok; else echo gone; fi', context);
+      if (answer.trim() !== "ok")
+        throw new AdapterError3("NOT_FOUND", "Freestyle process is absent");
+    }
+  };
+}
+function parseLauncher(text) {
+  const match = new RegExp(`^${PROCESS_RECORD} (\\S+)\\n$`).exec(text);
+  const directory = Directory2.safeParse(match?.[1]);
+  return directory.success ? directory.data : null;
+}
+
+// src/terminal.ts
+import {
+  AdapterError as AdapterError4
+} from "@beachside/adapter";
+import { randomBytes } from "node:crypto";
+import { z as z3 } from "zod";
+var TerminalSize = z3.strictObject({
+  columns: z3.number().int().min(1).max(1000),
+  rows: z3.number().int().min(1).max(1000)
+});
+var SessionSlug = z3.string().regex(/^beachside-term-[0-9a-f]{24}$/);
+var TerminalReference = z3.strictObject({
+  version: z3.literal(1),
+  kind: z3.literal("freestyle-pty"),
+  sandbox: z3.string().min(1).max(128),
+  session: SessionSlug
+});
+function terminalSlug() {
+  return `beachside-term-${randomBytes(12).toString("hex")}`;
+}
+function deferred2() {
+  let resolve;
+  let reject;
+  const promise = new Promise((accept, fail) => {
+    resolve = accept;
+    reject = fail;
+  });
+  promise.catch(() => {
+    return;
+  });
+  return { promise, resolve, reject };
+}
+async function openTerminal(driver, input, ctx) {
+  if (input.terminal && !TerminalSize.safeParse(input.terminal).success)
+    throw new AdapterError4("INVALID_ARGUMENT", "Freestyle terminal dimensions are invalid");
+  if (input.format === "bytes" && !ctx.onOutputBytes)
+    throw new AdapterError4("UNSUPPORTED", "Freestyle binary output requires a byte consumer hook");
+  const exited = deferred2();
+  const output = deferred2();
+  const capture = input.capture ? deferred2() : undefined;
+  const captureLimit = input.capture?.maxBytes ?? 0;
+  const captured = [];
+  let capturedBytes = 0;
+  let truncated = false;
+  const decoder = new TextDecoder;
+  let confirmedExit;
+  let outputDetached = false;
+  let detached = false;
+  let replaying = false;
+  const fail = () => new AdapterError4("UNAVAILABLE", "Freestyle terminal observation failed");
+  const lost = () => {
+    if (confirmedExit)
+      return;
+    const error = fail();
+    exited.reject(error);
+    output.reject(error);
+    capture?.reject(error);
+  };
+  const events = {
+    reconnect: false,
+    onReplayStart: () => {
+      replaying = input.command === undefined;
+    },
+    onReplayEnd: () => {
+      replaying = false;
+    },
+    onData(data) {
+      if (replaying || confirmedExit)
+        return;
+      if (capture) {
+        const take = Math.min(data.length, captureLimit - capturedBytes);
+        if (take > 0)
+          captured.push(data.slice(0, take));
+        capturedBytes += take;
+        if (take < data.length)
+          truncated = true;
+      }
+      if (outputDetached || detached || !data.length)
+        return;
+      try {
+        if (input.format === "bytes")
+          ctx.onOutputBytes({ stream: "stdout", bytes: new Uint8Array(data) });
+        else {
+          const text = decoder.decode(data, { stream: true });
+          if (text)
+            ctx.onOutput({ stream: "stdout", text });
+        }
+      } catch (error) {
+        outputDetached = true;
+        output.reject(error instanceof Error ? error : fail());
+      }
+    },
+    onExit(exitCode) {
+      if (confirmedExit)
+        return;
+      confirmedExit = { exitCode };
+      if (input.format === "text" && !outputDetached && !detached) {
+        const text = decoder.decode();
+        if (text)
+          ctx.onOutput({ stream: "stdout", text });
+      }
+      exited.resolve(confirmedExit);
+      capture?.resolve({
+        exitCode,
+        stdout: new Uint8Array(Buffer.concat(captured)),
+        stderr: new Uint8Array,
+        truncated
+      });
+      output.resolve();
+    },
+    onClose: lost,
+    onError: () => {
+      return;
+    }
+  };
+  let handle;
+  try {
+    handle = input.command ? await driver.open(input.vmId, {
+      exec: input.command,
+      cols: input.terminal?.columns ?? 80,
+      rows: input.terminal?.rows ?? 24,
+      slug: input.reference.session,
+      ...events
+    }) : await driver.attach(input.vmId, { session: input.reference.session, ...events });
+  } catch (error) {
+    if (error instanceof AdapterError4)
+      throw error;
+    throw new AdapterError4("UNAVAILABLE", "Freestyle terminal session did not open");
+  }
+  const live = () => {
+    if (detached)
+      throw fail();
+    if (confirmedExit)
+      throw new AdapterError4("NOT_FOUND", "Freestyle terminal has exited");
+  };
+  const send = (action) => {
+    live();
+    try {
+      action();
+    } catch {
+      throw new AdapterError4("UNAVAILABLE", "Freestyle terminal is disconnected");
+    }
+  };
+  async function disconnect() {
+    if (detached)
+      return;
+    detached = true;
+    handle.detach();
+    if (!confirmedExit)
+      exited.reject(fail());
+    output.reject(fail());
+    capture?.reject(fail());
+  }
+  return {
+    reference: input.reference,
+    async signal(signal) {
+      if (confirmedExit)
+        return { status: "not-found" };
+      if (signal !== "SIGKILL")
+        throw new AdapterError4("UNSUPPORTED", "Freestyle terminals accept SIGKILL only");
+      send(() => handle.signal("sigkill"));
+      return { status: "requested" };
+    },
+    async terminate() {
+      if (confirmedExit)
+        return { status: "not-found" };
+      send(() => handle.signal("sigkill"));
+      return { status: "requested" };
+    },
+    async resize(dimensions) {
+      if (!TerminalSize.safeParse(dimensions).success)
+        throw new AdapterError4("INVALID_ARGUMENT", "Freestyle terminal dimensions are invalid");
+      send(() => handle.resize({ cols: dimensions.columns, rows: dimensions.rows }));
+    },
+    async write(bytes) {
+      send(() => handle.write(new Uint8Array(bytes)));
+    },
+    async closeStdin() {
+      throw new AdapterError4("UNSUPPORTED", "Freestyle terminals do not have pipe EOF");
+    },
+    async status(context) {
+      const observedAt = new Date().toISOString();
+      if (confirmedExit)
+        return { state: "exited", exit: confirmedExit, observedAt };
+      const session = (await driver.list(input.vmId, context)).find((item) => item.slug === input.reference.session);
+      if (session?.state === "exited" && Number.isInteger(session.exitCode))
+        return { state: "exited", exit: { exitCode: Number(session.exitCode) }, observedAt };
+      return { state: session?.state === "running" ? "running" : "unknown", observedAt };
+    },
+    get confirmedExit() {
+      return confirmedExit;
+    },
+    outputDone: output.promise,
+    capture: capture?.promise,
+    wait: () => exited.promise,
+    async detachOutput() {
+      outputDetached = true;
+      output.reject(fail());
+    },
+    disconnect,
+    detach: disconnect
+  };
+}
+
+// src/transport.ts
+import { AdapterError as AdapterError5 } from "@beachside/adapter";
+import { Freestyle, FreestyleApiError } from "freestyle";
+var FREESTYLE_API = "https://api.freestyle.sh";
+var MAX_RESPONSE_BYTES = 32 * 1024 * 1024;
+var CANCELLED = "BEACHSIDE_CANCELLED";
+var RESULT_LOST = "BACKGROUND_RESULT_LOST";
+var BACKGROUND_ID = "x-freestyle-background-request-id";
+var inFlight = new Set(["VM_NON_RESPONSIVE"]);
+var background = /^BACKGROUND_/;
+var codes = new Map([
+  [400, "INVALID_ARGUMENT"],
+  [401, "UNAUTHENTICATED"],
+  [402, "CAPACITY"],
+  [403, "FORBIDDEN"],
+  [404, "NOT_FOUND"],
+  [409, "CONFLICT"],
+  [410, "NOT_FOUND"],
+  [413, "CAPACITY"],
+  [422, "INVALID_ARGUMENT"],
+  [429, "RATE_LIMIT"],
+  [503, "UNAVAILABLE"],
+  [504, "TIMEOUT"]
+]);
+var definitive = new Set([400, 401, 402, 403, 404, 410, 413, 422, 429]);
+
+class FetchRefused extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "FetchRefused";
+    this.reason = reason;
+  }
+}
+function clean(text, secrets) {
+  let value = text;
+  for (const secret of secrets)
+    if (secret)
+      value = value.replaceAll(secret, "[redacted]");
+  return value.replace(/Bearer\s+\S+/gi, "Bearer [redacted]").replace(/[\p{Cc}\s]+/gu, " ").trim().slice(0, 300);
+}
+function nativeFailure(error, secrets) {
+  if (error instanceof AdapterError5)
+    return { error };
+  if (error instanceof FetchRefused)
+    return {
+      error: new AdapterError5(error.reason === "bound" ? "CAPACITY" : "INTERNAL", error.message)
+    };
+  if (error instanceof FreestyleApiError) {
+    if (error.code === CANCELLED)
+      return {
+        code: error.code,
+        error: new AdapterError5("TIMEOUT", "Freestyle request was cancelled before it settled")
+      };
+    const code = error.code === "AGENT_UNSUPPORTED" ? "UNSUPPORTED" : codes.get(error.status) ?? (error.status >= 500 ? "UNAVAILABLE" : "INTERNAL");
+    const nativeCode = clean(error.code, secrets).slice(0, 128);
+    const detail = clean(error.message, secrets);
+    return {
+      status: error.status,
+      code: error.code,
+      error: new AdapterError5(code, `Freestyle API ${error.status}${nativeCode ? ` ${nativeCode}` : ""}${detail ? `: ${detail}` : ""}`)
+    };
+  }
+  const name = error instanceof Error ? error.name : "";
+  return {
+    error: new AdapterError5(name === "AbortError" || name === "TimeoutError" ? "TIMEOUT" : "UNAVAILABLE", "Freestyle API request did not complete")
+  };
+}
+function refusedBeforeEffect(failure) {
+  if (failure.status === undefined || background.test(failure.code ?? ""))
+    return false;
+  if (failure.status === 409)
+    return !inFlight.has(failure.code ?? "");
+  return definitive.has(failure.status);
+}
+async function bounded(response, limit) {
+  const init = {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  };
+  if (!response.body || [101, 204, 205, 304].includes(response.status))
+    return new Response(null, init);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let length = 0;
+  try {
+    for (;; ) {
+      const next = await reader.read();
+      if (next.done)
+        break;
+      length += next.value.byteLength;
+      if (length > limit)
+        throw new FetchRefused("bound", "Freestyle API response exceeds the adapter bound");
+      chunks.push(next.value);
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new Response(body, init);
+}
+function requestUrl(input) {
+  return new URL(input instanceof Request ? input.url : String(input));
+}
+function callFetch(base, signal, limit = MAX_RESPONSE_BYTES) {
+  const wrapped = async (input, init) => {
+    const url = requestUrl(input);
+    if (url.origin !== FREESTYLE_API)
+      throw new FetchRefused("origin", "Freestyle SDK requested another origin");
+    if (signal.aborted && url.pathname.startsWith("/v5/background-requests/"))
+      return new Response(JSON.stringify({ code: CANCELLED, message: "The Beachside call was cancelled" }), { status: 499, headers: { "content-type": "application/json" } });
+    const signals = init?.signal ? [signal, init.signal] : [signal];
+    const response = await base(input, {
+      ...init,
+      redirect: "error",
+      signal: AbortSignal.any(signals)
+    });
+    if (url.pathname.startsWith("/v5/background-requests/") && !response.ok && ![408, 429, 502, 503, 504].includes(response.status) && !response.headers.has(BACKGROUND_ID)) {
+      await response.body?.cancel().catch(() => {
+        return;
+      });
+      return new Response(JSON.stringify({
+        code: RESULT_LOST,
+        message: `Freestyle background result was unavailable (${response.status})`
+      }), { status: 500, headers: { "content-type": "application/json" } });
+    }
+    return bounded(response, limit);
+  };
+  return wrapped;
+}
+function createFreestyleClient(apiKey, base, signal, limit = MAX_RESPONSE_BYTES) {
+  return new Freestyle({ apiKey, baseUrl: FREESTYLE_API, fetch: callFetch(base, signal, limit) });
+}
+
+// src/adapter.ts
+var BASE_IMAGE = "freestyle/ubuntu";
+var MAX_EXEC_SECONDS = 86400;
+var MAX_OUTPUT_BYTES = 1048576;
+var MAX_STDIN_BYTES = 1048576;
+var MAX_FILE_BYTES = 8 * 1024 * 1024;
+var MAX_TTL_SECONDS = 30 * 24 * 60 * 60;
+var UBUNTU_SIZES = [
+  { image: "freestyle/ubuntu-sm", vcpus: 2, memoryMiB: 4096 },
+  { image: "freestyle/ubuntu", vcpus: 4, memoryMiB: 8192 },
+  { image: "freestyle/ubuntu-lg", vcpus: 8, memoryMiB: 16384 },
+  { image: "freestyle/ubuntu-xl", vcpus: 16, memoryMiB: 32768 },
+  { image: "freestyle/ubuntu-2xl", vcpus: 32, memoryMiB: 65536 }
+];
+var Image = z4.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9_.-]*(?:\/[A-Za-z0-9][A-Za-z0-9_.-]*)?$/, "Use a Freestyle snapshot id, your snapshot slug or a public owner/slug");
+var Lifetime = z4.number().int().min(60).max(MAX_TTL_SECONDS);
+var Configuration = z4.strictObject({
+  network: z4.enum(["blocked", "internet"]).default("blocked"),
+  image: Image.optional(),
+  resources: ResourceMinimums.optional(),
+  lifecycle: z4.strictObject({
+    lifetimeSeconds: Lifetime.default(DEFAULT_LIFETIME_SECONDS),
+    idleSeconds: Lifetime.optional()
+  }).default({ lifetimeSeconds: DEFAULT_LIFETIME_SECONDS }),
+  preview: z4.strictObject({
+    access: z4.enum(["public", "protected"]).default("public"),
+    ports: z4.array(PreviewPort).max(16).refine((ports) => new Set(ports).size === ports.length, "Preview ports must be unique").default([])
+  }).default({ access: "public", ports: [] }),
+  snapshots: z4.strictObject({
+    preserve: PreserveSchema.optional(),
+    retentionSeconds: z4.number().int().nonnegative().safe().optional()
+  }).optional()
+}).superRefine((value, ctx) => {
+  if (value.image !== undefined && value.resources !== undefined)
+    ctx.addIssue({
+      code: "custom",
+      path: ["resources"],
+      message: "Supply image or resources, not both; Freestyle snapshots keep the size they were built with"
+    });
+});
+var Credentials = z4.strictObject({ apiKey: z4.string().min(1) });
+var Id = z4.string().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
+var AttemptSlug = z4.string().regex(/^beachside-[0-9a-f]{24}$/);
+var CreateToken = z4.strictObject({
+  slug: AttemptSlug,
+  id: Id.optional(),
+  env: z4.literal(true).optional()
+});
+var DestroyToken = z4.strictObject({ id: Id, acknowledged: z4.boolean() });
+var ApiErrorBody = z4.object({ code: z4.string().max(256), message: z4.string().max(4096) });
+var LifecycleToken = z4.strictObject({
+  id: Id,
+  since: z4.number().int().nonnegative().optional()
+});
+var SnapshotSlug = z4.string().regex(/^beachside-snapshot-[0-9a-f]{24}$/);
+var CaptureToken = z4.strictObject({
+  slug: SnapshotSlug,
+  source: Id,
+  sourceState: z4.enum(["running", "suspended"]),
+  id: Id.optional()
+});
+var SnapshotDeleteToken = z4.strictObject({ id: Id });
+var snapshotProfile = {
+  id: "freestyle-vm",
+  preserve: Preserve.FILESYSTEM_AND_MEMORY,
+  sourceStates: ["running", "suspended"],
+  interruption: "pause",
+  sourceAfter: "unchanged",
+  connections: "unknown",
+  consistency: "unknown",
+  restoreExecution: "resume",
+  mountHandling: "none"
+};
+var snapshotSupport = {
+  status: "supported",
+  value: { profiles: [snapshotProfile], defaultProfileId: snapshotProfile.id }
+};
+var restoreSupport = {
+  networkPolicies: ["blocked", "internet"],
+  resources: false,
+  mounts: false,
+  independentLifecycle: true
+};
+function snapshotSlug(submissionId) {
+  return `beachside-snapshot-${createHash("sha256").update(submissionId).digest("hex").slice(0, 24)}`;
+}
+var Labels = z4.record(z4.string().min(1).max(63), z4.string().max(63)).refine((labels) => Object.keys(labels).length <= 64, "At most 64 labels");
+function attemptSlug(submissionId) {
+  return `beachside-${createHash("sha256").update(submissionId).digest("hex").slice(0, 24)}`;
+}
+function previewDomain(slug, port) {
+  return `${slug}-${port}.style.dev`;
+}
+function state(native) {
+  switch (native) {
+    case "starting":
+      return "creating";
+    case "running":
+      return "running";
+    case "paused":
+      return "suspended";
+    case "stopped":
+      return "stopped";
+    default:
+      return "unknown";
+  }
+}
+function vmSize(vm) {
+  const vcpus = vm.resources?.cpu ?? 0;
+  const memoryMiB = vm.resources?.memory ?? 0;
+  return Number.isFinite(vcpus) && vcpus > 0 && Number.isSafeInteger(memoryMiB) && memoryMiB > 0 ? { status: "known", value: { vcpus, memoryMiB } } : { status: "unknown", reason: "Freestyle did not report the VM size" };
+}
+function expiry(vm) {
+  if (vm.ttlSeconds === null || vm.ttlSeconds === undefined || vm.ttlSeconds < 0)
+    return { status: "none" };
+  const created = Date.parse(vm.createdAt);
+  return Number.isNaN(created) ? { status: "unknown", reason: "Freestyle reported no usable creation time" } : {
+    status: "known",
+    at: new Date(created + vm.ttlSeconds * 1000).toISOString(),
+    action: "destroy",
+    scope: "sandbox"
+  };
+}
+var OWNER_READ = `if [ -f "$1" ] && [ ! -h "$1" ]; then beachside_o=$(stat -c %u:%g -- "$1") || exit 1; if command -v python3 >/dev/null 2>&1; then echo "$beachside_o"; else echo "$beachside_o nopy"; fi; fi`;
+var OWNER_HELPER = `import hashlib,os,stat,sys
+p=sys.argv[2]
+u,g,n,h,r=int(sys.argv[3]),int(sys.argv[4]),int(sys.argv[5]),sys.argv[6],int(sys.argv[7])
+fd=os.open(p,os.O_RDONLY|os.O_NOFOLLOW|os.O_NONBLOCK)
+try:
+ st=os.fstat(fd)
+ if not stat.S_ISREG(st.st_mode) or st.st_uid!=r or st.st_nlink!=1 or st.st_size!=n:print('skip');sys.exit(0)
+ d=hashlib.sha256()
+ while True:
+  b=os.read(fd,1048576)
+  if not b:break
+  d.update(b)
+ if d.hexdigest()!=h:print('skip');sys.exit(0)
+ os.fchown(fd,u,g);print('ok')
+finally:os.close(fd)
+`;
+function readContext(signal, seconds = 30) {
+  return { signal, deadline: Date.now() + seconds * 1000 };
+}
+function callSignal(ctx) {
+  return AbortSignal.any([ctx.signal, AbortSignal.timeout(Math.max(1, ctx.deadline - Date.now()))]);
+}
+function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", stop);
+      resolve();
+    }, ms);
+    const stop = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", stop, { once: true });
+  });
+}
+function base64(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+}
+function createFreestyleAdapter(options = {}) {
+  const pollMs = options.pollIntervalMs ?? 1000;
+  const settleSeconds = options.settleSeconds ?? 120;
+  return defineAdapter({
+    name: "freestyle",
+    displayName: "Freestyle",
+    config: Configuration,
+    credentials: Credentials,
+    async connect({ config, credentials, host }) {
+      if (config.preview.access !== "public")
+        throw new AdapterError6("UNSUPPORTED", "Freestyle previews are public style.dev names; use preview.access public");
+      if (config.snapshots?.preserve === Preserve.FILESYSTEM)
+        throw new AdapterError6("UNSUPPORTED", "Freestyle snapshots always keep memory and disk; filesystem-only snapshots are not supported");
+      const image = config.image ?? (config.resources ? smallestSize("Freestyle", UBUNTU_SIZES, config.resources).image : BASE_IMAGE);
+      const base = options.fetch ?? globalThis.fetch;
+      const secrets = [credentials.apiKey];
+      const api = (signal, limit) => createFreestyleClient(credentials.apiKey, base, signal, limit);
+      const failure = (error) => nativeFailure(error, secrets);
+      const read = async (ctx, run) => {
+        try {
+          return await run(api(callSignal(ctx)));
+        } catch (error) {
+          throw failure(error).error;
+        }
+      };
+      await read(readContext(host.signal), (native) => native.vms.list({ limit: 1 }));
+      if (image.startsWith("sh-")) {
+        let found;
+        try {
+          found = await api(callSignal(readContext(host.signal))).vms.snapshots.get(image);
+        } catch (error) {
+          const native = failure(error);
+          if (native.status !== 404)
+            throw native.error;
+          found = null;
+        }
+        if (found?.id !== image)
+          throw new AdapterError6("NOT_FOUND", "Freestyle image snapshot is unavailable to this API key");
+      }
+      const scope = {
+        authority: {
+          kind: "api-key",
+          id: createHash("sha256").update("beachside:freestyle:api-key-scope:v1\x00").update(credentials.apiKey).digest("hex")
+        },
+        partition: { endpoint: FREESTYLE_API }
+      };
+      const checkedRef = (ref) => {
+        assertResourceScope(ref, { provider: "freestyle", scope });
+        if (ref.kind !== "sandbox" || ref.generation !== undefined || !Id.safeParse(ref.nativeId).success)
+          throw new AdapterError6("CONFLICT", "Invalid Freestyle VM identity");
+      };
+      const find = async (id, ctx) => {
+        Id.parse(id);
+        try {
+          const vm = await api(callSignal(ctx)).vms.get(id);
+          if (vm.id !== id)
+            throw new AdapterError6("CONFLICT", "Freestyle returned a different VM identity");
+          return vm;
+        } catch (error) {
+          const native = failure(error);
+          if (native.status === 404)
+            return null;
+          throw native.error;
+        }
+      };
+      const findBySlug = async (slug, ctx) => {
+        const page2 = await read(ctx, (native) => native.vms.list({ slug, limit: 2 }));
+        const matches = page2.vms.filter((vm) => vm.slug === slug);
+        if (matches.length > 1)
+          throw new AdapterError6("CONFLICT", "Freestyle returned several VMs for one slug");
+        return matches[0] ?? null;
+      };
+      const requireVm = async (box, ctx) => {
+        if (box.reference)
+          checkedRef(box.reference);
+        const vm = await find(box.id, ctx);
+        if (!vm)
+          throw new AdapterError6("NOT_FOUND", "Freestyle VM is unavailable in the verified account");
+        return vm;
+      };
+      const requireRunning = async (box, ctx) => {
+        const vm = await requireVm(box, ctx);
+        if (vm.state !== "running")
+          throw new AdapterError6("CONFLICT", `Freestyle VM is ${vm.state}; commands and files need a running VM`);
+        return vm;
+      };
+      const observation = (vm, ref) => ({
+        reference: ref,
+        state: state(vm.state),
+        nativeState: vm.state,
+        observedAt: new Date().toISOString(),
+        ...unknownSandboxFacts(),
+        expires: expiry(vm),
+        idleStop: {
+          status: "known",
+          value: vm.idleTimeoutSeconds !== null && vm.idleTimeoutSeconds !== undefined && vm.idleTimeoutSeconds > 0 ? { seconds: vm.idleTimeoutSeconds, action: "suspend" } : null
+        },
+        resources: vmSize(vm)
+      });
+      const partialCreate = (id, identity) => ({
+        kind: "create",
+        status: "partial",
+        sandbox: sandboxReference("freestyle", scope, id, {
+          operation: identity.operationId,
+          submission: identity.submissionId
+        }),
+        setup: { expiry: "acknowledged", readiness: "unconfirmed" }
+      });
+      const settle = async (signal, check) => {
+        const until = Date.now() + settleSeconds * 1000;
+        for (;; ) {
+          const value = await check(readContext(signal));
+          if (value !== undefined || Date.now() + pollMs > until)
+            return value;
+          await delay(pollMs, signal);
+        }
+      };
+      const rejection = (ctx, error, reason) => {
+        const native = failure(error);
+        return refusedBeforeEffect(native) ? ctx.reject(native.error.code, native.error.message) : ctx.unknown(`${reason}; do not replay`);
+      };
+      const partialRestore = (id, identity) => ({
+        kind: "snapshot_restore",
+        status: "unknown",
+        sandbox: sandboxReference("freestyle", scope, id, {
+          operation: identity.operationId,
+          submission: identity.submissionId
+        }),
+        mounts: []
+      });
+      const launched = (vm, token, identity, settle2, partial = partialCreate) => {
+        if (!vm)
+          return settle2.unknown(token.id ? "Freestyle VM disappeared before it was running; nothing remains to clean up" : "Freestyle create response was lost and no VM carries this attempt's slug; inspect inventory without replay");
+        if (vm.slug !== token.slug || token.id !== undefined && vm.id !== token.id)
+          return settle2.unknown("Freestyle VM identity differs from the attempt; do not replay");
+        if (vm.state === "running")
+          return {
+            id: vm.id,
+            reference: sandboxReference("freestyle", scope, vm.id, {
+              operation: identity.operationId,
+              submission: identity.submissionId
+            }),
+            state: "running"
+          };
+        if (vm.state === "starting")
+          return settle2.pending({ ...token, id: vm.id }, { pollAfterMs: pollMs });
+        return settle2.unknown(`Freestyle VM is ${vm.state} before it was running; inspect or destroy it`, partial(vm.id, identity));
+      };
+      const launch = async (input, ctx, partial = partialCreate) => {
+        const slug = attemptSlug(ctx.submissionId);
+        const request = {
+          snapshotId: input.image.value,
+          slug,
+          ttlSeconds: input.lifetimeSeconds ?? config.lifecycle.lifetimeSeconds,
+          firewall: firewall(input.networkPolicy)
+        };
+        if (config.lifecycle.idleSeconds !== undefined)
+          request.idleTimeoutSeconds = config.lifecycle.idleSeconds;
+        if (input.labels && Object.keys(input.labels).length)
+          request.metadata = input.labels;
+        const tls = previews(slug);
+        if (tls)
+          request.tls = tls;
+        const env = input.env && Object.keys(input.env).length ? input.env : undefined;
+        await ctx.checkpoint(env ? { slug, env: true } : { slug });
+        if (env)
+          launchEnv.set(slug, env);
+        let created;
+        try {
+          created = (await api(ctx.signal).vms.create(request)).data;
+        } catch (error) {
+          if (refusedBeforeEffect(failure(error)))
+            launchEnv.delete(slug);
+          return rejection(ctx, error, "Freestyle create response was not confirmed; observe finds the VM by its slug");
+        }
+        const id = Id.safeParse(created.id);
+        if (!id.success || created.slug !== slug)
+          return ctx.unknown("Freestyle create acknowledgement does not match the attempt");
+        const token = { slug, id: id.data };
+        if (env)
+          token.env = true;
+        try {
+          await ctx.checkpoint(token);
+        } catch (error) {
+          if (error instanceof AdapterCheckpointError)
+            error.outcome = partial(id.data, ctx);
+          throw error;
+        }
+        try {
+          const result = await settle(ctx.signal, async (read2) => {
+            const current = created.state === "running" ? created : await find(id.data, read2);
+            return current?.state === "starting" ? undefined : { current };
+          });
+          if (result?.current?.state === "running" && env) {
+            launchEnv.delete(slug);
+            if (!await writeEnv(id.data, env, slug, ctx.signal))
+              return ctx.unknown("Freestyle VM is running but its sandbox environment was not confirmed; destroy it", partial(id.data, ctx));
+          }
+          if (result)
+            return launched(result.current, token, ctx, ctx, partial);
+        } catch {}
+        return ctx.pending(token, { pollAfterMs: pollMs });
+      };
+      const launchEnv = new Map;
+      const writeEnv = (id, env, slug, signal) => api(callSignal(readContext(signal, 60))).vms.ref(id).fs.writeFile(ENV_FILE, envFile(env, slug), { mode: 384 }).then(() => true, () => false);
+      const observeLaunch = async (token, attempt, ctx, partial) => {
+        const vm = token.id ? await find(token.id, ctx) : await findBySlug(token.slug, ctx);
+        if (vm?.state === "running" && token.env) {
+          const env = launchEnv.get(token.slug);
+          launchEnv.delete(token.slug);
+          const written = env ? await writeEnv(vm.id, env, token.slug, ctx.signal) : await api(callSignal(ctx)).vms.ref(vm.id).fs.readTextFile(ENV_FILE).then((text) => text.startsWith(`${envMarker(token.slug)}
+`), () => false);
+          if (!written)
+            return ctx.unknown(env ? "Freestyle VM is running but its sandbox environment was not confirmed; destroy it" : "Freestyle VM is running but its sandbox environment was never written; destroy it", partial(vm.id, attempt));
+        }
+        if (vm?.state !== "starting")
+          launchEnv.delete(token.slug);
+        return launched(vm, token, attempt, ctx, partial);
+      };
+      const firewall = (policy) => policy === "internet" ? { rules: [{ action: "allow", source: {}, destination: { public: true } }] } : { rules: [] };
+      const previews = (slug) => config.preview.ports.length ? {
+        rules: config.preview.ports.map((port) => ({
+          action: "allow",
+          domain: previewDomain(slug, port),
+          source: { public: true },
+          destination: { port }
+        }))
+      } : undefined;
+      const runCommand = async (input, ctx) => {
+        const vm = api(callSignal(readContext(ctx.signal, input.deadlineSeconds + 60))).vms.ref(input.sandbox.id);
+        const request = {
+          command: wrapperScript({
+            ...input,
+            stdin: input.stdin !== undefined,
+            maxBytes: input.maxOutputBytes
+          }),
+          timeoutMs: Math.max(1, Math.ceil(input.deadlineSeconds)) * 1000
+        };
+        if (input.stdin !== undefined)
+          request.stdin = base64(input.stdin);
+        let response;
+        try {
+          response = await vm.exec(request);
+        } catch (error) {
+          return rejection(ctx, error, "Freestyle command response was not confirmed");
+        }
+        if (response.statusCode === null || response.statusCode === undefined)
+          return ctx.unknown(`Freestyle stopped the command at its ${input.deadlineSeconds}s deadline; output is unavailable`);
+        const record = parseWrapper(response.stdout ?? "");
+        if (!record)
+          return ctx.unknown("Freestyle ran the command but its result record could not be decoded");
+        if ("stdout" in record)
+          return record;
+        const files2 = api(callSignal(readContext(ctx.signal, 120)), input.maxOutputBytes + 1024).vms.ref(input.sandbox.id).fs;
+        const download = (stream) => files2.readFile(`${record.directory}/${stream}`).catch(() => null);
+        const stdout = await download("stdout");
+        const stderr = await download("stderr");
+        if (!stdout || !stderr)
+          return {
+            exitCode: record.exitCode,
+            stdout: stdout ?? new Uint8Array,
+            stderr: stderr ?? new Uint8Array,
+            truncated: true
+          };
+        const assembled = filesResult(record, stdout, stderr, input.maxOutputBytes);
+        if (!assembled)
+          return ctx.unknown("Freestyle command output is longer than its recorded length");
+        if (assembled.complete)
+          await api(callSignal(readContext(ctx.signal, 15))).vms.ref(input.sandbox.id).exec({ command: `rm -rf -- ${quote(record.directory)}`, timeoutMs: 1e4 }).catch(() => {
+            return;
+          });
+        return assembled.result;
+      };
+      const putFile = async (vmId, path, bytes, signal) => {
+        const vm = api(callSignal(readContext(signal, 120))).vms.ref(vmId);
+        const asRoot = async (command) => {
+          const result = await vm.exec({ command, linuxUser: "root", timeoutMs: 1e4 });
+          if (result.statusCode !== 0)
+            throw new AdapterError6("UNAVAILABLE", "Freestyle file owner command failed");
+          return (result.stdout ?? "").trim();
+        };
+        let owner;
+        try {
+          owner = await asRoot(`sh -c ${quote(OWNER_READ)} beachside-owner ${quote(path)}`);
+        } catch (error) {
+          throw error instanceof AdapterError6 ? error : failure(error).error;
+        }
+        const parsed = /^(\d{1,10}):(\d{1,10})( nopy)?$/.exec(owner);
+        if (owner && !parsed)
+          throw new AdapterError6("UNAVAILABLE", "Freestyle file owner is malformed");
+        const keepOwner = parsed && !(parsed[1] === "0" && parsed[2] === "0");
+        if (keepOwner && parsed[3])
+          throw new AdapterError6("UNSUPPORTED", "Freestyle needs Python 3 in the image to replace a file another user owns");
+        await vm.fs.writeFile(path, bytes);
+        if (!keepOwner)
+          return true;
+        const digest = createHash("sha256").update(bytes).digest("hex");
+        return asRoot(`python3 -I -c ${quote(OWNER_HELPER)} ${[
+          "restore",
+          path,
+          parsed[1] ?? "",
+          parsed[2] ?? "",
+          String(bytes.byteLength),
+          digest,
+          "0"
+        ].map(quote).join(" ")}`).then((result) => result === "ok", () => false);
+      };
+      const nativeEntries = async (vmId, path, ctx) => {
+        const entries = await read(ctx, (native) => native.vms.ref(vmId).fs.readDir(path));
+        if (entries.length > MAX_DIRECTORY_ENTRIES)
+          throw new AdapterError6("CAPACITY", "Freestyle directory exceeds the listing bound");
+        return entries.map((entry) => ({
+          name: entry.name,
+          type: entry.kind === "file" || entry.kind === "directory" || entry.kind === "symlink" ? entry.kind : "unknown"
+        }));
+      };
+      const nativeStat = async (vmId, path, ctx) => {
+        const native = await read(ctx, (client) => client.vms.ref(vmId).fs.stat(path));
+        if (!/^0?[0-7]{1,4}$/.test(native.permissions) || !Number.isSafeInteger(native.size) || native.size < 0)
+          throw new AdapterError6("UNAVAILABLE", "Freestyle metadata response is invalid");
+        const stat = {
+          type: native.isSymlink ? "symlink" : native.isFile ? "file" : native.isDirectory ? "directory" : "unknown",
+          sizeBytes: native.size,
+          mode: Number.parseInt(native.permissions, 8) & 511
+        };
+        const modified = /^\d{1,12}(\.\d+)?$/.test(native.modified) ? Number(native.modified) * 1000 : Date.parse(native.modified);
+        if (native.modified && !Number.isFinite(modified))
+          throw new AdapterError6("UNAVAILABLE", "Freestyle metadata response is invalid");
+        if (native.modified)
+          stat.modifiedAt = new Date(modified).toISOString();
+        return stat;
+      };
+      const guest = (vmId) => async (command, ctx, stdin) => {
+        const request = {
+          command,
+          timeoutMs: Math.max(1000, Math.min(300000, ctx.deadline - Date.now()))
+        };
+        if (stdin)
+          request.stdin = base64(stdin);
+        let response;
+        try {
+          response = await api(callSignal(ctx)).vms.ref(vmId).exec(request);
+        } catch (error) {
+          throw failure(error).error;
+        }
+        if (response.statusCode !== 0)
+          throw new AdapterError6(response.statusCode === null || response.statusCode === undefined ? "TIMEOUT" : "UNAVAILABLE", "Freestyle guest control command failed");
+        return response.stdout ?? "";
+      };
+      const held = new Map;
+      const release = (vmId) => {
+        if (!held.get(vmId)?.inFlight)
+          held.delete(vmId);
+      };
+      const holding = async (vmId) => {
+        const hold = held.get(vmId);
+        if (!hold)
+          return false;
+        if (hold.inFlight || Date.now() - hold.checkedAt < 2000)
+          return true;
+        hold.checkedAt = Date.now();
+        const vm = await find(vmId, readContext(AbortSignal.timeout(1e4), 10)).catch(() => {
+          return;
+        });
+        if (vm === null) {
+          held.delete(vmId);
+          return false;
+        }
+        if (vm?.state !== "running")
+          return true;
+        release(vmId);
+        return held.has(vmId);
+      };
+      const jobOptions = (vmId) => ({
+        held: () => holding(vmId),
+        run: guest(vmId),
+        pollMs: options.processPollMs ?? 250,
+        requestSeconds: 60
+      });
+      const files = (vmId) => filesystem(guest(vmId), async (path, offset, length, ctx) => {
+        const route = `/v5/vms/${encodeURIComponent(vmId)}/fs/read?${new URLSearchParams({ path })}`;
+        let response;
+        try {
+          response = await api(callSignal(ctx), length + 1024).fetch(route, {
+            method: "GET",
+            headers: { range: `bytes=${offset}-${offset + length - 1}` }
+          });
+        } catch (error) {
+          throw failure(error).error;
+        }
+        if (!response.ok && response.status !== 416) {
+          const parsed = ApiErrorBody.safeParse(await response.json().catch(() => {
+            return;
+          }));
+          const body = parsed.success ? parsed.data : { code: "UNKNOWN_ERROR", message: `HTTP ${response.status}` };
+          throw failure(new FreestyleApiError2(response.status, body, route)).error;
+        }
+        const result = await rangeResult(response, offset, length);
+        if (!result)
+          throw new AdapterError6("UNAVAILABLE", "Freestyle file range is malformed");
+        return result;
+      });
+      const fileRejection = (ctx, error) => {
+        if (error instanceof AdapterFilesystemError2 && error.details.effect !== "none")
+          return ctx.unknown("Freestyle filesystem operation may have changed the requested path; do not replay");
+        if (error instanceof AdapterError6)
+          return ctx.reject(error.code, error.message);
+        return ctx.unknown("Freestyle filesystem response was not confirmed; do not replay");
+      };
+      const pty = options.pty ?? {
+        open: (vmId, request) => api(host.signal).vms.ref(vmId).pty.open(request),
+        attach: (vmId, request) => api(host.signal).vms.ref(vmId).pty.attach(request),
+        list: async (vmId, ctx) => (await read(ctx, (native) => native.vms.ref(vmId).pty.list())).sessions
+      };
+      const listedReference = (vm) => Id.safeParse(vm.id).success ? {
+        version: 1,
+        kind: "sandbox",
+        provider: "freestyle",
+        scope,
+        nativeId: vm.id,
+        ownership: "unknown"
+      } : null;
+      const page = async (input, ctx) => {
+        const offset = input.cursor === undefined ? 0 : Number(input.cursor);
+        if (!Number.isSafeInteger(offset) || offset < 0)
+          throw new AdapterError6("INVALID_ARGUMENT", "Invalid Freestyle VM cursor");
+        const limit = Math.min(100, input.limit);
+        const listed = await read(ctx, (native) => native.vms.list({ limit, offset }));
+        const next = offset + listed.vms.length;
+        return {
+          vms: listed.vms.filter((vm) => Id.safeParse(vm.id).success),
+          nextCursor: listed.vms.length === limit && next < listed.totalCount ? String(next) : undefined
+        };
+      };
+      const snapshotRef = (id, ownership = "unknown") => ({
+        version: 1,
+        kind: "snapshot",
+        provider: "freestyle",
+        scope,
+        nativeId: id,
+        ownership
+      });
+      const checkedSnapshot = (ref) => {
+        assertResourceScope(ref, { provider: "freestyle", scope });
+        if (ref.kind !== "snapshot" || ref.generation !== undefined || !Id.safeParse(ref.nativeId).success)
+          throw new AdapterError6("CONFLICT", "Invalid Freestyle snapshot identity");
+        return ref.nativeId;
+      };
+      const findSnapshot = async (id, ctx) => {
+        try {
+          const snapshot = await api(callSignal(ctx)).vms.snapshots.get(id);
+          if (snapshot.id !== id)
+            throw new AdapterError6("CONFLICT", "Freestyle returned a different snapshot identity");
+          return snapshot;
+        } catch (error) {
+          const native = failure(error);
+          if (native.status === 404)
+            return null;
+          throw native.error;
+        }
+      };
+      const requireSnapshot = async (ref, ctx) => {
+        const snapshot = await findSnapshot(checkedSnapshot(ref), ctx);
+        if (!snapshot)
+          throw new AdapterError6("NOT_FOUND", "Freestyle snapshot is unavailable");
+        return snapshot;
+      };
+      const findSnapshotBySlug = async (slug, source, ctx) => {
+        const matches = [];
+        for (let offset = 0;; ) {
+          const listed = await read(ctx, (native) => native.vms.snapshots.list({ sourceVmId: source, limit: 100, offset }));
+          matches.push(...listed.snapshots.filter((snapshot) => snapshot.slug === slug));
+          offset += listed.snapshots.length;
+          if (!listed.snapshots.length || offset >= listed.totalCount)
+            break;
+        }
+        if (matches.length > 1)
+          throw new AdapterError6("CONFLICT", "Freestyle returned several snapshots for one slug");
+        return matches[0] ?? null;
+      };
+      const snapshotInfo = (snapshot, ref) => ({
+        reference: ref,
+        preserve: Preserve.FILESYSTEM_AND_MEMORY,
+        restoreExecution: "resume",
+        consistency: "unknown",
+        source: snapshot.sourceVmId && Id.safeParse(snapshot.sourceVmId).success ? { id: snapshot.sourceVmId, class: "freestyle-vm" } : null,
+        state: "ready",
+        createdAt: listedTime(snapshot.createdAt),
+        expiration: "unknown",
+        excludedPaths: null,
+        mounts: [],
+        mountHandling: "none",
+        restore: restoreSupport,
+        dependencies: [],
+        nativeDependencies: null
+      });
+      const imageInfo = (snapshot) => ({
+        reference: {
+          version: 1,
+          kind: "image",
+          provider: "freestyle",
+          scope,
+          nativeId: snapshot.id,
+          ownership: "unknown"
+        },
+        state: "ready",
+        createdAt: listedTime(snapshot.createdAt),
+        source: null,
+        visibility: snapshot.public ? "public" : "private",
+        nativeDependencies: null
+      });
+      const snapshotPage = async (input, ctx) => {
+        const offset = input.cursor === undefined ? 0 : Number(input.cursor);
+        if (!Number.isSafeInteger(offset) || offset < 0)
+          throw new AdapterError6("INVALID_ARGUMENT", "Invalid Freestyle snapshot cursor");
+        const limit = Math.min(100, input.limit);
+        const listed = await read(ctx, (native) => native.vms.snapshots.list({ limit, offset }));
+        const next = offset + listed.snapshots.length;
+        return {
+          snapshots: listed.snapshots.filter((snapshot) => Id.safeParse(snapshot.id).success),
+          nextCursor: listed.snapshots.length === limit && next < listed.totalCount ? String(next) : undefined
+        };
+      };
+      const captureResult = (token, snapshot, settle2) => {
+        if (!snapshot)
+          return settle2.unknown("Freestyle snapshot response was lost and no snapshot carries this attempt's slug; list snapshots without replay");
+        if (snapshot.slug !== token.slug || snapshot.sourceVmId !== token.source || token.id !== undefined && snapshot.id !== token.id || !Id.safeParse(snapshot.id).success)
+          return settle2.unknown("Freestyle snapshot identity differs from the attempt; do not replay");
+        const ref = snapshotRef(snapshot.id, "verified-created");
+        return {
+          snapshot: snapshotInfo(snapshot, ref),
+          capture: {
+            preserve: snapshotProfile.preserve,
+            interruption: snapshotProfile.interruption,
+            restoreExecution: snapshotProfile.restoreExecution
+          },
+          source: { state: token.sourceState, connections: snapshotProfile.connections },
+          retainedResources: [ref]
+        };
+      };
+      const session = {
+        scope,
+        defaultImage: { kind: "prepared", value: image },
+        defaultNetworkPolicy: config.network,
+        supports: {
+          images: ["prepared"],
+          network: ["blocked", "internet"],
+          exec: { commands: ["argv", "shell"], maxOutputBytes: MAX_OUTPUT_BYTES },
+          fileWrite: { overwrite: true, noClobber: true },
+          createEnv: true,
+          lifetime: { minSeconds: 60, maxSeconds: MAX_TTL_SECONDS }
+        },
+        create: {
+          recovery: { version: 1, token: CreateToken },
+          async prepare(input) {
+            if (input.image.kind !== "prepared")
+              throw new AdapterError6("UNSUPPORTED", "Freestyle boots snapshots only; OCI images are unavailable");
+            if (!Image.safeParse(input.image.value).success)
+              throw new AdapterError6("INVALID_ARGUMENT", "Freestyle images are a snapshot id, your snapshot slug or a public owner/slug");
+            if (input.networkPolicy !== "blocked" && input.networkPolicy !== "internet")
+              throw new AdapterError6("UNSUPPORTED", "Freestyle network policies are blocked and internet; allowlists are unavailable");
+            if (config.resources && input.image.value !== image) {
+              const size = UBUNTU_SIZES.find((candidate) => candidate.image === input.image.value);
+              if (!size || config.resources.vcpus !== undefined && size.vcpus < config.resources.vcpus || config.resources.memoryMiB !== undefined && size.memoryMiB < config.resources.memoryMiB)
+                throw new AdapterError6("UNSUPPORTED", "This image may not meet the configured resources; Freestyle snapshots keep the size they were built with");
+            }
+            if (input.region !== undefined || input.mounts?.length || input.requirements)
+              throw new AdapterError6("UNSUPPORTED", "Freestyle has no region selection, volume mounts or snapshot requirements");
+            if (input.labels && !Labels.safeParse(input.labels).success)
+              throw new AdapterError6("INVALID_ARGUMENT", "Freestyle labels allow at most 64 entries with keys and values up to 63 characters");
+            checkEnv(input.env);
+            return input;
+          },
+          submit: (input, ctx) => launch(input, ctx),
+          async observe(attempt, ctx) {
+            const token = CreateToken.safeParse(attempt.token);
+            if (!token.success || token.data.slug !== attemptSlug(attempt.submissionId))
+              return ctx.unknown("Freestyle create identity is unavailable; do not replay");
+            return observeLaunch(token.data, attempt, ctx, partialCreate);
+          }
+        },
+        async inspect(box, ctx) {
+          if (box.reference)
+            checkedRef(box.reference);
+          const vm = await find(box.id, ctx);
+          return vm ? { id: vm.id, ...observation(vm, box.reference ?? null) } : null;
+        },
+        async reopen(ref, ctx) {
+          checkedRef(ref);
+          return observation(await requireVm({ id: ref.nativeId, reference: ref }, ctx), ref);
+        },
+        async inventory(input, ctx) {
+          const listed = await page(input, ctx);
+          return {
+            items: listed.vms.map((vm) => ({
+              id: vm.id,
+              state: vm.state === "running" ? "running" : "unknown"
+            })),
+            nextCursor: listed.nextCursor
+          };
+        },
+        async sandboxList(input, ctx) {
+          const listed = await page(input, ctx);
+          return {
+            coverage: "provider-scope",
+            items: listed.vms.map((vm) => ({
+              id: vm.id,
+              state: state(vm.state),
+              reference: listedReference(vm),
+              labels: listedLabels(vm.metadata, () => false),
+              createdAt: listedTime(vm.createdAt)
+            })),
+            nextCursor: listed.nextCursor
+          };
+        },
+        destroy: {
+          recovery: { version: 1, token: DestroyToken },
+          async prepare(input, ctx) {
+            await requireVm(input, ctx);
+            return input;
+          },
+          async submit(input, ctx) {
+            const token = { id: Id.parse(input.id), acknowledged: false };
+            await ctx.checkpoint(token);
+            try {
+              await api(callSignal(readContext(ctx.signal))).vms.delete(token.id);
+            } catch (error) {
+              const native = failure(error);
+              if (refusedBeforeEffect(native))
+                return ctx.reject(native.error.code, native.error.message);
+              return ctx.pending(token, { pollAfterMs: pollMs });
+            }
+            const acknowledged = { ...token, acknowledged: true };
+            await ctx.checkpoint(acknowledged);
+            try {
+              const gone = await settle(ctx.signal, async (read2) => await find(token.id, read2) ? undefined : true);
+              if (gone)
+                return { computeStopped: true, retainedResources: [] };
+            } catch {}
+            return ctx.pending(acknowledged, { pollAfterMs: pollMs });
+          },
+          async observe(attempt, ctx) {
+            const token = DestroyToken.safeParse(attempt.token);
+            if (!token.success || token.data.id !== attempt.sandbox?.id)
+              return ctx.unknown("Freestyle deletion identity is unavailable; do not replay");
+            if (!await find(token.data.id, ctx))
+              return { computeStopped: true, retainedResources: [] };
+            return token.data.acknowledged ? ctx.pending(token.data, { pollAfterMs: pollMs }) : ctx.unknown("Freestyle delete response was lost and the VM still exists; destroy it again explicitly");
+          }
+        },
+        processes: {
+          supports: {
+            sustainedOutput: true,
+            binaryOutput: true,
+            signals: ["SIGTERM", "SIGKILL"],
+            terminal: true,
+            reopen: true,
+            stdin: "bytes",
+            status: true,
+            execCapture: "bytes"
+          },
+          async start(input, ctx) {
+            if (input.capture && (!Number.isSafeInteger(input.capture.maxBytes) || input.capture.maxBytes < 1 || input.capture.maxBytes > MAX_OUTPUT_BYTES))
+              throw new AdapterError6("CAPACITY", "Freestyle process capture exceeds its byte bound");
+            commandLine(input);
+            await requireRunning(input.sandbox, ctx);
+            const format = input.output?.format ?? "text";
+            if (input.terminal) {
+              if (input.stdin === "closed")
+                throw new AdapterError6("UNSUPPORTED", "Freestyle terminals always take input");
+              return openTerminal(pty, {
+                vmId: input.sandbox.id,
+                command: commandLine({ ...input, env: { TERM: "xterm-256color", ...input.env } }),
+                terminal: input.terminal,
+                reference: {
+                  version: 1,
+                  kind: "freestyle-pty",
+                  sandbox: input.sandbox.id,
+                  session: terminalSlug()
+                },
+                format,
+                capture: input.capture
+              }, ctx);
+            }
+            const directory = parseLauncher(await guest(input.sandbox.id)(launcherScript(input), ctx));
+            if (!directory)
+              throw new AdapterError6("UNAVAILABLE", "Freestyle process start was not acknowledged");
+            return observeJob(jobOptions(input.sandbox.id), {
+              version: 1,
+              kind: "freestyle-job",
+              sandbox: input.sandbox.id,
+              directory,
+              stdin: input.stdin ?? "closed"
+            }, { format, capture: input.capture, fromEnd: false }, ctx);
+          },
+          async reopen(input, ctx) {
+            await requireRunning(input.sandbox, ctx);
+            release(input.sandbox.id);
+            const job = ProcessReference.safeParse(input.reference);
+            const terminal = TerminalReference.safeParse(input.reference);
+            if (job.success && job.data.sandbox === input.sandbox.id && input.profile === "process" && job.data.stdin === input.stdin)
+              return observeJob(jobOptions(input.sandbox.id), job.data, { format: input.output.format, fromEnd: true }, ctx);
+            if (terminal.success && terminal.data.sandbox === input.sandbox.id && input.profile === "terminal")
+              return openTerminal(pty, {
+                vmId: input.sandbox.id,
+                reference: terminal.data,
+                format: input.output.format
+              }, ctx);
+            throw new AdapterError6("CONFLICT", "Process reference does not belong to this Freestyle VM and profile");
+          }
+        },
+        exec: {
+          finiteStdin: "bytes",
+          async prepare(input, ctx) {
+            if (input.deadlineSeconds > MAX_EXEC_SECONDS)
+              throw new AdapterError6("INVALID_ARGUMENT", `Freestyle commands run for at most ${MAX_EXEC_SECONDS} seconds`);
+            if (input.stdin !== undefined && input.stdin.byteLength > MAX_STDIN_BYTES)
+              throw new AdapterError6("CAPACITY", `Freestyle command stdin is limited to ${MAX_STDIN_BYTES} bytes`);
+            wrapperScript({ ...input, stdin: false, maxBytes: input.maxOutputBytes });
+            await requireRunning(input.sandbox, ctx);
+            return input;
+          },
+          submit: (input, ctx) => runCommand(input, ctx)
+        },
+        async preview(input, ctx) {
+          const vm = await requireRunning(input.sandbox, ctx);
+          const published = async () => (await read(ctx, (native) => native.tls.rules.list({ vmId: vm.id }))).rules.find((candidate) => candidate.action === "allow" && candidate.source.public === true && candidate.destination.vmId === vm.id && candidate.destination.port === input.port && /^[a-z0-9-]{1,63}\.style\.dev$/.test(candidate.domain));
+          let rule = await published();
+          if (!rule) {
+            if (!vm.slug || !AttemptSlug.safeParse(vm.slug).success)
+              throw new AdapterError6("UNSUPPORTED", "Only VMs created by Beachside get style.dev preview names");
+            try {
+              await api(callSignal(ctx)).tls.rules.create({
+                action: "allow",
+                domain: previewDomain(vm.slug, input.port),
+                source: { public: true },
+                destination: { vmId: vm.id, port: input.port }
+              });
+            } catch (error) {
+              const native = failure(error);
+              if (native.status !== 409)
+                throw native.error;
+            }
+            rule = await published();
+          }
+          if (!rule)
+            throw new AdapterError6("UNAVAILABLE", "Freestyle did not publish the preview port");
+          return { access: "public", url: `https://${rule.domain}` };
+        },
+        files: {
+          maxBytes: MAX_FILE_BYTES,
+          async read(input, ctx) {
+            await requireVm(input.sandbox, ctx);
+            const limit = Math.min(input.maxBytes ?? MAX_FILE_BYTES, MAX_FILE_BYTES);
+            try {
+              const bytes = await api(callSignal(ctx), limit + 1).vms.ref(input.sandbox.id).fs.readFile(input.path);
+              if (bytes.byteLength > limit)
+                throw new AdapterError6("CAPACITY", "Freestyle file exceeds the read bound");
+              return bytes;
+            } catch (error) {
+              throw failure(error).error;
+            }
+          },
+          write: {
+            async prepare(input, ctx) {
+              if (input.bytes.byteLength > MAX_FILE_BYTES)
+                throw new AdapterError6("CAPACITY", "Freestyle file exceeds the write bound");
+              await requireRunning(input.sandbox, ctx);
+              return input;
+            },
+            async submit(input, ctx) {
+              if (!input.overwrite)
+                try {
+                  return await files(input.sandbox.id).write(input.path, [input.bytes], false, readContext(ctx.signal, 120));
+                } catch (error) {
+                  return fileRejection(ctx, error);
+                }
+              try {
+                if (!await putFile(input.sandbox.id, input.path, input.bytes, ctx.signal))
+                  return ctx.unknown("Freestyle wrote the file but could not restore its owner; inspect it");
+              } catch (error) {
+                if (error instanceof AdapterError6)
+                  return ctx.reject(error.code, error.message);
+                return rejection(ctx, error, "Freestyle file write was not confirmed");
+              }
+              return { bytesWritten: input.bytes.byteLength };
+            }
+          },
+          async readDirectory(input, ctx) {
+            if ((await requireVm(input.sandbox, ctx)).state !== "running")
+              return {
+                entries: (await nativeEntries(input.sandbox.id, input.path, ctx)).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
+                completeness: "complete",
+                observedAt: new Date().toISOString()
+              };
+            return directoryValue(await files(input.sandbox.id).helper("list", input.path, "", false, ctx));
+          },
+          async stat(input, ctx) {
+            if ((await requireVm(input.sandbox, ctx)).state !== "running") {
+              if (!input.followSymlinks)
+                throw new AdapterError6("CONFLICT", "Freestyle reports a link's own metadata only on a running VM");
+              return nativeStat(input.sandbox.id, input.path, ctx);
+            }
+            return statValue(await files(input.sandbox.id).helper("stat", input.path, "", input.followSymlinks, ctx));
+          },
+          async exists(input, ctx) {
+            if ((await requireVm(input.sandbox, ctx)).state !== "running")
+              return read(ctx, (native) => native.vms.ref(input.sandbox.id).fs.exists(input.path));
+            return Exists.parse(await files(input.sandbox.id).helper("exists", input.path, "", false, ctx)).exists;
+          },
+          async readStream(input, ctx) {
+            await requireVm(input.sandbox, ctx);
+            return files(input.sandbox.id).read(input.path, ctx);
+          },
+          async writeStream(input, ctx) {
+            await requireRunning(input.sandbox, ctx);
+            const iterator = input.bytes[Symbol.asyncIterator]();
+            const head = [];
+            let size = 0;
+            let ended = false;
+            while (input.overwrite && size <= MAX_FILE_BYTES) {
+              const next = await iterator.next();
+              if (next.done) {
+                ended = true;
+                break;
+              }
+              head.push(next.value);
+              size += next.value.length;
+            }
+            if (ended) {
+              try {
+                const restored = await putFile(input.sandbox.id, input.path, new Uint8Array(Buffer.concat(head)), ctx.signal);
+                if (!restored)
+                  throw new AdapterFilesystemError2("UNAVAILABLE", "Freestyle wrote the file but could not restore its owner; inspect it", {
+                    effect: "applied",
+                    source: input.path,
+                    destination: input.path,
+                    temporaryPaths: []
+                  });
+              } catch (error) {
+                if (error instanceof AdapterError6)
+                  throw error;
+                const native = failure(error);
+                if (refusedBeforeEffect(native))
+                  throw native.error;
+                throw new AdapterFilesystemError2("UNAVAILABLE", "Freestyle file write was not confirmed; do not replay", {
+                  effect: "possible",
+                  source: input.path,
+                  destination: input.path,
+                  temporaryPaths: []
+                });
+              }
+              ctx.retain?.({ effect: "applied", temporaryPaths: [], bytesTransferred: size });
+              return { bytesWritten: size };
+            }
+            async function* rest() {
+              yield* head;
+              for (let next = await iterator.next();!next.done; next = await iterator.next())
+                yield next.value;
+            }
+            return files(input.sandbox.id).write(input.path, rest(), input.overwrite, ctx);
+          },
+          async copy(input, ctx) {
+            await requireRunning(input.sandbox, ctx);
+            return files(input.sandbox.id).transfer("copy", input.source, input.destination, input.overwrite, ctx);
+          },
+          async move(input, ctx) {
+            await requireRunning(input.sandbox, ctx);
+            return files(input.sandbox.id).transfer("move", input.source, input.destination, input.overwrite, ctx);
+          },
+          makeDirectory: {
+            async prepare(input, ctx) {
+              await requireRunning(input.sandbox, ctx);
+              return input;
+            },
+            async submit(input, ctx) {
+              try {
+                await files(input.sandbox.id).helper("mkdir", input.path, "", input.recursive, readContext(ctx.signal));
+                return { acknowledged: true };
+              } catch (error) {
+                return fileRejection(ctx, error);
+              }
+            }
+          },
+          remove: {
+            async prepare(input, ctx) {
+              await requireRunning(input.sandbox, ctx);
+              return input;
+            },
+            async submit(input, ctx) {
+              try {
+                await files(input.sandbox.id).helper("remove", input.path, "", input.recursive, readContext(ctx.signal));
+                return { acknowledged: true };
+              } catch (error) {
+                return fileRejection(ctx, error);
+              }
+            }
+          },
+          async list(input, ctx) {
+            await requireVm(input.sandbox, ctx);
+            return nativeEntries(input.sandbox.id, input.path, ctx);
+          }
+        },
+        async suspensionCapabilities() {
+          return {
+            status: "supported",
+            value: {
+              preserve: Preserve.FILESYSTEM_AND_MEMORY,
+              processes: "preserved",
+              connections: "dropped"
+            }
+          };
+        },
+        async resumeCapabilities() {
+          return {
+            status: "supported",
+            value: { sourceStates: ["suspended"], setsSessionTimeout: false }
+          };
+        },
+        suspend: {
+          recovery: { version: 1, token: LifecycleToken },
+          async prepare(input, ctx) {
+            const vm = await requireVm(input.sandbox, ctx);
+            if (vm.state !== "running")
+              throw new AdapterError6("CONFLICT", `Freestyle can pause only a running VM, not ${vm.state}`);
+            return {
+              ...input,
+              intent: { action: "suspend", preserve: Preserve.FILESYSTEM_AND_MEMORY }
+            };
+          },
+          async submit(input, ctx) {
+            const token = { id: Id.parse(input.sandbox.id), since: Date.now() };
+            await ctx.checkpoint(token);
+            const hold = { inFlight: true, checkedAt: 0 };
+            held.set(token.id, hold);
+            try {
+              try {
+                await api(callSignal(readContext(ctx.signal, 120))).vms.ref(token.id).pause();
+              } catch (error) {
+                const rejected = rejection(ctx, error, "Freestyle pause response was not confirmed");
+                if (refusedBeforeEffect(failure(error)))
+                  held.delete(token.id);
+                return rejected;
+              }
+              try {
+                const paused = await settle(ctx.signal, async (read2) => {
+                  const vm = await find(token.id, read2);
+                  return vm?.state === "paused" ? vm : undefined;
+                });
+                if (paused) {
+                  hold.checkedAt = Date.now();
+                  return suspended(paused, input.sandbox.reference);
+                }
+              } catch {}
+              return ctx.pending(token, { pollAfterMs: pollMs });
+            } finally {
+              hold.inFlight = false;
+            }
+          },
+          async observe(attempt, ctx) {
+            const token = LifecycleToken.safeParse(attempt.token);
+            const box = attempt.sandbox;
+            if (!token.success || !box?.reference || token.data.id !== box.id)
+              return ctx.unknown("Freestyle pause identity is unavailable; do not replay");
+            const vm = await find(token.data.id, ctx);
+            if (!vm) {
+              held.delete(token.data.id);
+              return ctx.unknown("Freestyle VM disappeared while pausing");
+            }
+            if (vm.state === "paused") {
+              const hold = held.get(vm.id);
+              if (hold)
+                hold.checkedAt = Date.now();
+              else
+                held.set(vm.id, { inFlight: false, checkedAt: Date.now() });
+              return suspended(vm, box.reference);
+            }
+            const waiting = vm.state === "pausing" || vm.state === "running" && Date.now() - (token.data.since ?? 0) < settleSeconds * 1000;
+            if (waiting)
+              return ctx.pending(token.data, { pollAfterMs: pollMs });
+            held.delete(token.data.id);
+            return ctx.unknown(vm.state === "running" ? "Freestyle acknowledged the pause but the VM kept running; inspect it before retrying" : `Freestyle VM is ${vm.state} after pause; inspect without replay`);
+          }
+        },
+        resume: {
+          recovery: { version: 1, token: LifecycleToken },
+          async prepare(input, ctx) {
+            const vm = await requireVm(input.sandbox, ctx);
+            if (vm.state !== "paused")
+              throw new AdapterError6("CONFLICT", `Freestyle can resume only a paused VM, not ${vm.state}`);
+            return { ...input, intent: { action: "resume" } };
+          },
+          async submit(input, ctx) {
+            const token = { id: Id.parse(input.sandbox.id) };
+            await ctx.checkpoint(token);
+            try {
+              await api(callSignal(readContext(ctx.signal, 120))).vms.ref(token.id).start();
+            } catch (error) {
+              return rejection(ctx, error, "Freestyle start response was not confirmed");
+            }
+            try {
+              const ready = await settle(ctx.signal, async (read2) => {
+                const vm = await find(token.id, read2);
+                return vm?.state === "running" ? vm : undefined;
+              });
+              if (ready) {
+                release(token.id);
+                return resumed(ready, input.sandbox.reference);
+              }
+            } catch {}
+            return ctx.pending(token, { pollAfterMs: pollMs });
+          },
+          async observe(attempt, ctx) {
+            const token = LifecycleToken.safeParse(attempt.token);
+            const box = attempt.sandbox;
+            if (!token.success || !box?.reference || token.data.id !== box.id)
+              return ctx.unknown("Freestyle resume identity is unavailable; do not replay");
+            const vm = await find(token.data.id, ctx);
+            if (!vm)
+              return ctx.unknown("Freestyle VM disappeared while resuming");
+            if (vm.state === "running") {
+              release(vm.id);
+              return resumed(vm, box.reference);
+            }
+            return vm.state === "paused" || vm.state === "starting" ? ctx.pending(token.data, { pollAfterMs: pollMs }) : ctx.unknown(`Freestyle VM is ${vm.state} after resume; inspect without replay`);
+          }
+        },
+        async renewCapabilities() {
+          return {
+            status: "supported",
+            value: {
+              minSeconds: 60,
+              maxSeconds: MAX_TTL_SECONDS,
+              stepSeconds: 1,
+              scope: "sandbox"
+            }
+          };
+        },
+        renew: {
+          async prepare(input, ctx) {
+            await requireVm(input.sandbox, ctx);
+            const forSeconds = input.forSeconds ?? config.lifecycle.lifetimeSeconds;
+            if (forSeconds < 60 || forSeconds > MAX_TTL_SECONDS)
+              throw new AdapterError6("INVALID_ARGUMENT", `Freestyle lifetimes are 60 to ${MAX_TTL_SECONDS} seconds`);
+            return { ...input, forSeconds };
+          },
+          async submit(input, ctx) {
+            const current = await find(input.sandbox.id, readContext(ctx.signal));
+            if (!current)
+              return ctx.reject("NOT_FOUND", "Freestyle VM is unavailable in the verified account");
+            const created = Date.parse(current.createdAt);
+            if (Number.isNaN(created))
+              return ctx.reject("UNSUPPORTED", "Freestyle reported no usable creation time");
+            const ttlSeconds = Math.ceil(Math.max(0, Date.now() - created) / 1000) + input.forSeconds;
+            let vm;
+            try {
+              vm = await api(callSignal(readContext(ctx.signal))).vms.ref(input.sandbox.id).update({ ttlSeconds });
+            } catch (error) {
+              return rejection(ctx, error, "Freestyle lifetime update was not confirmed");
+            }
+            return {
+              reference: input.sandbox.reference,
+              requested: { forSeconds: input.forSeconds },
+              acknowledged: true,
+              observation: vm.id === input.sandbox.id ? observation(vm, input.sandbox.reference) : null
+            };
+          }
+        },
+        snapshotProfiles: async () => snapshotSupport,
+        snapshotCapture: {
+          recovery: { version: 1, token: CaptureToken },
+          async prepare(input, ctx) {
+            if (input.request.retention?.cleanupAfterSeconds === 0)
+              throw new AdapterError6("INVALID_ARGUMENT", "Freestyle snapshot cleanup needs at least 1 second; omit it to keep the snapshot");
+            const vm = await requireVm(input.sandbox, ctx);
+            const plan = resolveSnapshot(snapshotSupport, input.request, state(vm.state));
+            if (plan.status !== "supported")
+              throw new AdapterError6("UNSUPPORTED", plan.reason);
+            return {
+              ...input,
+              expectation: { profile: plan.value.profile, sourceState: plan.value.sourceState }
+            };
+          },
+          async submit(input, ctx) {
+            const token = {
+              slug: snapshotSlug(ctx.submissionId),
+              source: Id.parse(input.sandbox.id),
+              sourceState: input.expectation?.sourceState === "suspended" ? "suspended" : "running"
+            };
+            const request = { slug: token.slug };
+            const ttlSeconds = input.request.retention?.cleanupAfterSeconds ?? config.snapshots?.retentionSeconds;
+            if (ttlSeconds)
+              request.ttlSeconds = ttlSeconds;
+            await ctx.checkpoint(token);
+            let created;
+            try {
+              created = await api(callSignal(readContext(ctx.signal, 600))).vms.ref(token.source).snapshot(request);
+            } catch (error) {
+              const native = failure(error);
+              return refusedBeforeEffect(native) ? ctx.reject(native.error.code, native.error.message) : ctx.pending(token, { pollAfterMs: pollMs });
+            }
+            const id = Id.safeParse(created.snapshotId);
+            if (!id.success)
+              return ctx.unknown("Freestyle snapshot acknowledgement has no usable id; do not replay");
+            const tracked = { ...token, id: id.data };
+            await ctx.checkpoint(tracked);
+            return captureResult(tracked, { ...created.snapshot, id: id.data }, ctx);
+          },
+          async observe(attempt, ctx) {
+            const token = CaptureToken.safeParse(attempt.token);
+            if (!token.success || token.data.source !== attempt.sandbox?.id || token.data.slug !== snapshotSlug(attempt.submissionId))
+              return ctx.unknown("Freestyle capture identity is unavailable; do not replay");
+            const snapshot = token.data.id ? await findSnapshot(token.data.id, ctx) : await findSnapshotBySlug(token.data.slug, token.data.source, ctx);
+            return captureResult(token.data, snapshot, ctx);
+          }
+        },
+        snapshotRestore: {
+          recovery: { version: 1, token: CreateToken },
+          options: {
+            env: true,
+            labels: true,
+            lifetime: { minSeconds: 60, maxSeconds: MAX_TTL_SECONDS }
+          },
+          async prepare(input, ctx) {
+            if (input.request.resources || input.request.mounts?.length)
+              throw new AdapterError6("UNSUPPORTED", "Freestyle restores keep the snapshot's VM size and take no mounts");
+            if (!restoreSupport.networkPolicies.includes(input.request.networkPolicy))
+              throw new AdapterError6("UNSUPPORTED", "Freestyle network policies are blocked and internet");
+            checkEnv(input.request.env);
+            if (input.request.labels && !Labels.safeParse(input.request.labels).success)
+              throw new AdapterError6("INVALID_ARGUMENT", "Freestyle labels allow at most 64 entries with keys and values up to 63 characters");
+            await requireSnapshot(input.snapshot, ctx);
+            return input;
+          },
+          submit: (input, ctx) => launch({
+            image: { kind: "prepared", value: input.snapshot.nativeId },
+            networkPolicy: input.request.networkPolicy,
+            labels: input.request.labels,
+            env: input.request.env,
+            lifetimeSeconds: input.request.lifetimeSeconds
+          }, ctx, partialRestore),
+          async observe(attempt, ctx) {
+            const token = CreateToken.safeParse(attempt.token);
+            if (!attempt.resource || !token.success || token.data.slug !== attemptSlug(attempt.submissionId))
+              return ctx.unknown("Freestyle restore identity is unavailable; do not replay");
+            checkedSnapshot(attempt.resource);
+            return observeLaunch(token.data, attempt, ctx, partialRestore);
+          }
+        },
+        async snapshotInspect(ref, ctx) {
+          return snapshotInfo(await requireSnapshot(ref, ctx), ref);
+        },
+        snapshotListCoverage: "provider-scope",
+        async snapshotList(input, ctx) {
+          const listed = await snapshotPage(input, ctx);
+          return {
+            items: listed.snapshots.map((snapshot) => snapshotInfo(snapshot, snapshotRef(snapshot.id))),
+            nextCursor: listed.nextCursor,
+            coverage: "provider-scope"
+          };
+        },
+        snapshotDelete: {
+          recovery: { version: 1, token: SnapshotDeleteToken },
+          async prepare(ref, ctx) {
+            await requireSnapshot(ref, ctx);
+            return ref;
+          },
+          async submit(ref, ctx) {
+            const token = { id: checkedSnapshot(ref) };
+            await ctx.checkpoint(token);
+            try {
+              await api(callSignal(readContext(ctx.signal))).vms.snapshots.delete(token.id);
+            } catch (error) {
+              const native = failure(error);
+              if (refusedBeforeEffect(native))
+                return ctx.reject(native.error.code, native.error.message);
+              return ctx.pending(token, { pollAfterMs: pollMs });
+            }
+            return { deleted: true, reference: ref };
+          },
+          async observe(attempt, ctx) {
+            const token = SnapshotDeleteToken.safeParse(attempt.token);
+            const ref = attempt.resource;
+            if (!token.success || !ref || checkedSnapshot(ref) !== token.data.id)
+              return ctx.unknown("Freestyle snapshot deletion identity is unavailable; do not replay");
+            return await findSnapshot(token.data.id, ctx) ? ctx.unknown("Freestyle snapshot still exists; deletion was not confirmed, so delete it again explicitly") : { deleted: true, reference: ref };
+          }
+        },
+        async imageInspect(ref, ctx) {
+          assertResourceScope(ref, { provider: "freestyle", scope });
+          if (ref.kind !== "image" || !Id.safeParse(ref.nativeId).success)
+            throw new AdapterError6("CONFLICT", "Invalid Freestyle image identity");
+          const snapshot = await findSnapshot(ref.nativeId, ctx);
+          if (!snapshot)
+            throw new AdapterError6("NOT_FOUND", "Freestyle snapshot is unavailable");
+          return imageInfo(snapshot);
+        },
+        imageListCoverage: "provider-scope",
+        async imageList(input, ctx) {
+          const listed = await snapshotPage(input, ctx);
+          return {
+            items: listed.snapshots.map(imageInfo),
+            nextCursor: listed.nextCursor,
+            coverage: "provider-scope"
+          };
+        },
+        async resourceCapabilities() {
+          return {
+            restore: { status: "supported", value: restoreSupport },
+            volumes: { status: "unsupported", reason: "Freestyle has no volumes" },
+            mounts: { status: "unsupported", reason: "Freestyle has no volume mounts" }
+          };
+        }
+      };
+      const suspended = (vm, reference) => ({
+        reference,
+        preserve: Preserve.FILESYSTEM_AND_MEMORY,
+        processes: "preserved",
+        connections: "dropped",
+        observation: observation(vm, reference)
+      });
+      const resumed = (vm, reference) => ({
+        reference,
+        execution: "resumed",
+        executionIdentity: unknownSandboxFacts().execution,
+        connections: "dropped",
+        observation: observation(vm, reference)
+      });
+      return session;
+    }
+  });
+}
+var freestyleAdapter = createFreestyleAdapter();
+// src/factory.ts
+import { bindAdapter } from "@beachside/adapter";
+function freestyle(options) {
+  const { apiKey, ...config } = options;
+  return bindAdapter(freestyleAdapter, config, { apiKey });
+}
+export {
+  freestyleAdapter,
+  freestyle,
+  createFreestyleAdapter,
+  BASE_IMAGE
+};