@wular/coder 0.3.17 → 0.4.0

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/router-JNKHLBCZ.js

@@ -0,0 +1,503 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  getNextConfig
+} from "./chunk-2ICEVELW.js";
+import {
+  hasUseClientDirective
+} from "./chunk-L2IWDUXG.js";
+import "./chunk-JESFYECC.js";
+import "./chunk-5RDEILQB.js";
+import "./chunk-NQE46AZN.js";
+import {
+  listFiles,
+  listFilesSync,
+  toPosixPath
+} from "./chunk-2HFY3DQT.js";
+import "./chunk-4P5CMIYT.js";
+import "./chunk-FTJVHFWD.js";
+import "./chunk-3UPROT2C.js";
+
+// ../node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/pages/router.ts
+import { createHash } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+import {
+  copyFile,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  symlink,
+  writeFile
+} from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+var basePageExtensions = ["tsx", "ts", "jsx", "js", "mjs"];
+function materializeExtensions() {
+  const configured = getNextConfig().pageExtensions;
+  const extras = Array.isArray(configured) ? configured.filter((ext) => typeof ext === "string" && ext.length > 0) : [];
+  return [.../* @__PURE__ */ new Set([...basePageExtensions, ...extras])];
+}
+var appConventions = /* @__PURE__ */ new Set([
+  "default",
+  "error",
+  "forbidden",
+  "global-error",
+  "layout",
+  "loading",
+  "not-found",
+  "page",
+  "route",
+  "template",
+  "unauthorized"
+]);
+var metadataConventionPattern = /^(robots|sitemap|manifest|icon\d*|apple-icon\d*|opengraph-image\d*|twitter-image\d*)$/;
+function isAppConvention(name) {
+  return appConventions.has(name) || metadataConventionPattern.test(name);
+}
+async function materializePagesApp(root) {
+  const pagesPath = path.join(root, "pages");
+  if (!existsSync(pagesPath)) return void 0;
+  const nativeApp = path.join(root, "app");
+  const pages = await discoverPages(pagesPath);
+  const apiRoutes = await discoverPagesApi(pagesPath);
+  if (pages.length === 0 && apiRoutes.length === 0) return void 0;
+  const generatedRoot = path.join(
+    tmpdir(),
+    "pnext-pages-compat",
+    materializationKey(root, nativeApp, pages, apiRoutes)
+  );
+  const appPath = path.join(generatedRoot, "app");
+  if (existsSync(appPath)) return appPath;
+  const staging = `${generatedRoot}.${process.pid.toString(36)}.staging`;
+  await buildMaterializedApp(staging, root, pagesPath, nativeApp, pages, apiRoutes);
+  try {
+    await rename(staging, generatedRoot);
+  } catch {
+    await rm(staging, { recursive: true, force: true });
+    if (!existsSync(appPath)) throw new Error(`pnext: could not materialize ${root}/pages`);
+  }
+  void sweepStaleMaterializations(path.dirname(generatedRoot));
+  return appPath;
+}
+function materializationKey(root, nativeApp, pages, apiRoutes) {
+  const stamp = (file) => {
+    const info = statSync(file, { throwIfNoEntry: false });
+    return info ? `${info.size}:${info.mtimeMs}` : "";
+  };
+  const nativeFiles = existsSync(nativeApp) ? listFilesSync(nativeApp).map((file) => `${toPosixPath(path.relative(nativeApp, file))}\0${stamp(file)}`).sort() : [];
+  const byRelative = (routes) => [...routes].sort((a, b) => a.relative.localeCompare(b.relative));
+  return createHash("sha256").update(
+    JSON.stringify([
+      root,
+      materializeExtensions(),
+      byRelative(pages),
+      byRelative(apiRoutes),
+      nativeFiles,
+      stamp(fileURLToPath("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/pages/router.ts"))
+    ])
+  ).digest("hex").slice(0, 16);
+}
+var STALE_MATERIALIZATION_MS = 7 * 24 * 60 * 6e4;
+async function sweepStaleMaterializations(base) {
+  try {
+    const cutoff = Date.now() - STALE_MATERIALIZATION_MS;
+    for (const entry of await readdir(base)) {
+      const dir = path.join(base, entry);
+      const info = statSync(dir, { throwIfNoEntry: false });
+      if (info && info.mtimeMs < cutoff) await rm(dir, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+async function buildMaterializedApp(generatedRoot, root, pagesPath, nativeApp, pages, apiRoutes) {
+  const appPath = path.join(generatedRoot, "app");
+  const sourcePages = path.join(generatedRoot, "source-pages");
+  const sourceApp = path.join(generatedRoot, "source-app");
+  await rm(generatedRoot, { recursive: true, force: true });
+  await mkdir(appPath, { recursive: true });
+  await symlink(pagesPath, sourcePages, "dir");
+  const nodeModules = path.join(root, "node_modules");
+  if (existsSync(nodeModules))
+    await symlink(nodeModules, path.join(generatedRoot, "node_modules"), "dir");
+  const publicDir = path.join(root, "public");
+  if (existsSync(publicDir)) await symlink(publicDir, path.join(generatedRoot, "public"), "dir");
+  if (existsSync(nativeApp)) {
+    await symlink(nativeApp, sourceApp, "dir");
+    await materializeNativeApp(sourceApp, appPath);
+  }
+  if (!existsSync(path.join(appPath, "layout.js"))) {
+    await writeFile(
+      path.join(appPath, "layout.js"),
+      "export default function PagesLayout({ children }) {\n  return <html><body>{children}</body></html>\n}\n"
+    );
+  }
+  for (const page of pages) {
+    const destination = path.join(appPath, ...encodePrivateSegments(page.segments), "page.js");
+    if (existsSync(destination)) continue;
+    await mkdir(path.dirname(destination), { recursive: true });
+    const pagesPattern = `/${page.segments.join("/")}`.replace(/\/+$/, "") || "/";
+    const sourceSpecifier = relativeImport(destination, path.join(sourcePages, page.relative));
+    let clientSpecifier;
+    if (page.hasStaticProps || page.hasServerSideProps) {
+      const clientDestination = path.join(path.dirname(destination), "pnext-page-client.js");
+      await writeFile(
+        clientDestination,
+        `'use client';
+export { default } from ${JSON.stringify(sourceSpecifier)};
+`
+      );
+      clientSpecifier = "./pnext-page-client.js";
+    }
+    await writeFile(
+      destination,
+      wrapperSource(
+        sourceSpecifier,
+        // A pages-router component is implicitly a client module: it SSRs AND
+        // hydrates (hooks, event handlers, next/router). Without the client
+        // wrapper it renders as a server component and never becomes
+        // interactive. Data functions keep a server wrapper and pass their
+        // props into the page's client facade.
+        !page.hasServerSideProps && !page.hasStaticProps,
+        page.hasServerSideProps,
+        page.hasStaticProps,
+        clientSpecifier,
+        page.runtime,
+        page.maxDuration,
+        pagesPattern
+      )
+    );
+  }
+  for (const apiRoute of apiRoutes) {
+    const destination = path.join(appPath, "api", ...apiRoute.segments, "route.js");
+    if (existsSync(destination)) continue;
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeFile(
+      destination,
+      pagesApiWrapperSource(
+        relativeImport(destination, path.join(sourcePages, apiRoute.relative)),
+        apiRoute.runtime
+      )
+    );
+  }
+}
+async function materializeNativeApp(sourceApp, appPath) {
+  for (const file of await listFiles(sourceApp)) {
+    const relative = toPosixPath(path.relative(sourceApp, file));
+    const parsed = path.parse(relative);
+    if (!materializeExtensions().includes(parsed.ext.slice(1))) {
+      const destination2 = path.join(appPath, relative);
+      await mkdir(path.dirname(destination2), { recursive: true });
+      await copyFile(file, destination2);
+      continue;
+    }
+    if (!isAppConvention(parsed.name)) continue;
+    const destination = path.join(appPath, parsed.dir, `${parsed.name}.js`);
+    await mkdir(path.dirname(destination), { recursive: true });
+    const source = await readFile(file, "utf8");
+    const client = hasUseClientDirective(source) || await defaultExportImportsClientModule(file, source);
+    await writeFile(
+      destination,
+      wrapperSource(
+        relativeImport(destination, file),
+        client,
+        false,
+        false,
+        void 0,
+        runtimeFromSource(source)
+      )
+    );
+  }
+}
+async function defaultExportImportsClientModule(file, source) {
+  const defaultExport = /export\s+default\s+([A-Za-z_$][\w$]*)\s*;?/.exec(source);
+  if (!defaultExport?.[1]) return false;
+  const binding = defaultExport[1];
+  const imports = /import\s*\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g;
+  let match;
+  while (match = imports.exec(source)) {
+    const importsBinding = (match[1] ?? "").split(",").some((value) => {
+      const names = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(value);
+      return (names?.[2] ?? names?.[1]) === binding;
+    });
+    if (!importsBinding || !match[2]?.startsWith(".")) continue;
+    const imported = resolveSourceImport(file, match[2]);
+    if (imported && hasUseClientDirective(await readFile(imported, "utf8"))) return true;
+  }
+  return false;
+}
+function resolveSourceImport(file, specifier) {
+  const base = path.resolve(path.dirname(file), specifier);
+  for (const candidate of [
+    base,
+    ...materializeExtensions().flatMap((extension) => [
+      `${base}.${extension}`,
+      path.join(base, `index.${extension}`)
+    ])
+  ]) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return void 0;
+}
+function encodePrivateSegments(segments) {
+  return segments.map((segment) => segment.startsWith("_") ? `%5F${segment.slice(1)}` : segment);
+}
+async function discoverPages(pagesPath) {
+  const routes = /* @__PURE__ */ new Map();
+  const files = await listFiles(pagesPath);
+  for (const extension of materializeExtensions()) {
+    for (const file of files) {
+      if (!file.endsWith(`.${extension}`)) continue;
+      const relative = toPosixPath(path.relative(pagesPath, file));
+      const withoutExtension = relative.slice(0, -extension.length - 1);
+      const sourceSegments = withoutExtension.split("/");
+      if (sourceSegments[0] === "api") continue;
+      if (sourceSegments.length === 1 && (sourceSegments[0] === "_app" || sourceSegments[0] === "_document" || sourceSegments[0] === "_error")) {
+        continue;
+      }
+      const segments = sourceSegments.at(-1) === "index" ? sourceSegments.slice(0, -1) : sourceSegments;
+      const key = segments.join("/");
+      if (!routes.has(key)) {
+        const source = await readFile(file, "utf8");
+        routes.set(key, {
+          relative,
+          segments,
+          hasServerSideProps: /\bgetServerSideProps\b/.test(source),
+          hasStaticProps: /\bgetStaticProps\b/.test(source),
+          runtime: runtimeFromSource(source),
+          maxDuration: maxDurationFromSource(source)
+        });
+      }
+    }
+  }
+  return [...routes.values()];
+}
+async function discoverPagesApi(pagesPath) {
+  const routes = /* @__PURE__ */ new Map();
+  const files = await listFiles(path.join(pagesPath, "api"));
+  for (const extension of materializeExtensions()) {
+    for (const file of files) {
+      if (!file.endsWith(`.${extension}`)) continue;
+      const relative = toPosixPath(path.relative(pagesPath, file));
+      const segments = relative.slice(0, -extension.length - 1).split("/").slice(1);
+      if (segments.some((segment) => segment.startsWith("_"))) continue;
+      const key = segments.join("/");
+      if (routes.has(key)) continue;
+      routes.set(key, {
+        relative,
+        segments,
+        runtime: runtimeFromSource(await readFile(file, "utf8"))
+      });
+    }
+  }
+  return [...routes.values()];
+}
+function routerStateModulePath() {
+  return path.join("/Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/src/compat/pages", "router-state.ts");
+}
+function routerStateSnippet(pagesPattern) {
+  if (!pagesPattern) {
+    return { imports: "", render: "return createElement(Page, result?.props ?? {});" };
+  }
+  return {
+    imports: `import { pagesRouterSsrState, serializePagesRouterState } from ${JSON.stringify(
+      routerStateModulePath()
+    )};
+`,
+    render: `const routerState = pagesRouterSsrState(${JSON.stringify(pagesPattern)}, resolvedParams);
+  return createElement(
+    Fragment,
+    null,
+    createElement('script', {
+      type: 'application/json',
+      id: '__PNEXT_PAGES_DATA__',
+      dangerouslySetInnerHTML: { __html: serializePagesRouterState(routerState) },
+    }),
+    createElement(Page, result?.props ?? {}),
+  );`
+  };
+}
+function wrapperSource(specifier, client = false, hasServerSideProps = false, hasStaticProps = false, clientSpecifier, runtime, maxDuration, pagesPattern) {
+  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};
+` : "";
+  const maxDurationExport = maxDuration === void 0 ? "" : `export const maxDuration = ${maxDuration};
+`;
+  const routerState = routerStateSnippet(pagesPattern);
+  if (hasStaticProps && clientSpecifier) {
+    return `import { createElement, Fragment } from 'react';
+import { notFound, redirect } from 'next/navigation';
+import Page from ${JSON.stringify(clientSpecifier)};
+import * as pageModule from ${JSON.stringify(specifier)};
+${routerState.imports}export * from ${JSON.stringify(specifier)};
+${runtimeExport}${maxDurationExport}export default async function PagesCompatStaticPage({ params }) {
+  // The otel compat exposes a span wrapper (Render.getStaticProps) at runtime.
+  const withSpan = globalThis.__PNEXT_PAGES_DATA_SPAN__ ?? ((kind, fn) => fn());
+  const resolvedParams = await params;
+  const invoke = async () => pageModule.getStaticProps?.({ params: resolvedParams });
+  const result = await withSpan('getStaticProps', invoke);
+  if (result?.notFound) notFound();
+  if (result?.redirect) redirect(result.redirect.destination);
+  ${routerState.render}
+}
+`;
+  }
+  if (!hasServerSideProps) {
+    if (client) {
+      return `'use client';
+export { default } from ${JSON.stringify(specifier)};
+${runtimeExport}${maxDurationExport}`;
+    }
+    return `import * as __pnext_page_ns from ${JSON.stringify(specifier)};
+export default __pnext_page_ns.default;
+export * from ${JSON.stringify(specifier)};
+${runtimeExport}${maxDurationExport}`;
+  }
+  return `import { createElement, Fragment } from 'react';
+import { notFound, redirect } from 'next/navigation';
+import { cookies, headers } from 'next/headers';
+import Page from ${JSON.stringify(clientSpecifier)};
+import * as pageModule from ${JSON.stringify(specifier)};
+${routerState.imports}export * from ${JSON.stringify(specifier)};
+export const dynamic = 'force-dynamic';
+${runtimeExport}${maxDurationExport}export default async function PagesCompatPage({ params, searchParams }) {
+  // The otel compat exposes a span wrapper (Render.getServerSideProps) at runtime.
+  const withSpan = globalThis.__PNEXT_PAGES_DATA_SPAN__ ?? ((kind, fn) => fn());
+  const resolvedParams = await params;
+  // getServerSideProps reads a node-shaped \`req\`/\`res\`. This page is
+  // force-dynamic, so headers()/cookies() are available; \`method\` is always
+  // 'GET' and \`res\` is inert (writes are dropped) \u2014 a workable baseline until
+  // the pages layer threads the real request through.
+  const requestHeaders = Object.fromEntries((await headers()).entries());
+  const requestCookies = Object.fromEntries(
+    (await cookies()).getAll().map(cookie => [cookie.name, cookie.value]),
+  );
+  const invoke = async () => pageModule.getServerSideProps?.({
+    params: resolvedParams,
+    query: (await searchParams) ?? {},
+    req: {
+      headers: requestHeaders,
+      cookies: requestCookies,
+      method: 'GET',
+      url: ${JSON.stringify(pagesPattern ?? "/")},
+    },
+    res: {
+      statusCode: 200,
+      setHeader() {},
+      getHeader() {},
+      getHeaders() { return {}; },
+      removeHeader() {},
+      end() {},
+      write() { return true; },
+    },
+    resolvedUrl: ${JSON.stringify(pagesPattern ?? "/")},
+    preview: false,
+    previewData: undefined,
+    draftMode: false,
+  });
+  const result = await withSpan('getServerSideProps', invoke);
+  if (result?.notFound) notFound();
+  if (result?.redirect) redirect(result.redirect.destination);
+  ${routerState.render}
+}
+`;
+}
+function runtimeFromSource(source) {
+  const runtime = /\bruntime\b\s*[:=]\s*(['"`])(edge|nodejs|experimental-edge)\1/.exec(source)?.[2];
+  return runtime === "experimental-edge" ? "edge" : runtime;
+}
+function maxDurationFromSource(source) {
+  const value = /\bmaxDuration\s*:\s*(\d+)\b/.exec(source)?.[1];
+  return value === void 0 ? void 0 : Number(value);
+}
+function pagesApiWrapperSource(specifier, runtime) {
+  const runtimeExport = runtime ? `export const runtime = ${JSON.stringify(runtime)};
+` : "";
+  return `import handler from ${JSON.stringify(specifier)};
+import { NextRequest } from 'next/server';
+import { Writable } from 'node:stream';
+${runtimeExport}export async function GET(request) {
+  return run(handler, request);
+}
+export async function POST(request) {
+  return run(handler, request);
+}
+export async function PUT(request) {
+  return run(handler, request);
+}
+export async function PATCH(request) {
+  return run(handler, request);
+}
+export async function DELETE(request) {
+  return run(handler, request);
+}
+// Bridge a pages-API handler onto the app-route Response contract. Edge-style
+// handlers (request-only, return a Response) pass through; node-style handlers
+// get a real Writable \`res\` whose bytes stream into the Response body, with
+// client disconnects surfaced as res 'close'/destroy (stream cancellation).
+async function run(handler, request) {
+  const nextRequest = request instanceof NextRequest ? request : new NextRequest(request);
+  const state = { status: 200, headers: new Headers() };
+  let controller;
+  let started = false;
+  let notifyStarted = () => {};
+  const startedPromise = new Promise(resolve => { notifyStarted = resolve; });
+  const start = () => {
+    if (!started) {
+      started = true;
+      notifyStarted();
+    }
+  };
+  const body = new ReadableStream({
+    start(c) { controller = c; },
+    cancel() { res.destroy(); },
+  });
+  const enqueue = chunk => {
+    try {
+      controller.enqueue(typeof chunk === 'string' ? new TextEncoder().encode(chunk) : new Uint8Array(chunk));
+    } catch {}
+  };
+  const res = new Writable({
+    write(chunk, _encoding, callback) { start(); enqueue(chunk); callback(); },
+    final(callback) { start(); try { controller.close(); } catch {} callback(); },
+    destroy(error, callback) { try { controller.close(); } catch {} callback(error); },
+  });
+  Object.defineProperty(res, 'statusCode', {
+    get: () => state.status,
+    set: value => { state.status = value; },
+  });
+  res.setHeader = (name, value) => { state.headers.set(name, String(value)); return res; };
+  res.getHeader = name => state.headers.get(name) ?? undefined;
+  res.removeHeader = name => { state.headers.delete(name); };
+  res.status = code => { state.status = code; return res; };
+  res.json = value => { state.headers.set('content-type', 'application/json'); res.end(JSON.stringify(value)); };
+  res.send = value => { res.end(value); };
+  // A client disconnect aborts the request signal; pages handlers observe it
+  // as the response closing (res.on('close') per Node semantics).
+  request.signal?.addEventListener?.('abort', () => res.destroy(), { once: true });
+  const finished = Promise.resolve()
+    .then(() => handler(nextRequest, res))
+    .catch(error => {
+      if (!started) throw error;
+      try { controller.error(error); } catch {}
+    });
+  const outcome = await Promise.race([
+    startedPromise.then(() => 'started'),
+    finished.then(() => 'done'),
+  ]);
+  if (outcome === 'done' && !started) {
+    const result = await finished;
+    return result instanceof Response ? result : new Response(null, { status: state.status, headers: state.headers });
+  }
+  return new Response(body, { status: state.status, headers: state.headers });
+}
+`;
+}
+function relativeImport(fromFile, targetFile) {
+  const relative = toPosixPath(path.relative(path.dirname(fromFile), targetFile));
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+export {
+  materializePagesApp
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/routes-PD6J2NXW.js

@@ -0,0 +1,52 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  addClientEntryReason,
+  assertNoServerActionsWithoutCompat,
+  collectFileCss,
+  collectNotFoundCss,
+  findConventionFiles,
+  findGlobalError,
+  findLayouts,
+  matchInterception,
+  matchRoute,
+  materializeRouteFacts,
+  materializeRouteFactsPaced,
+  normalizePathname,
+  parseNavState,
+  routeFactsResolved,
+  routeFactsVersion,
+  scanRoutes,
+  selectRouteForRequest,
+  serverActionsUnsupportedMessage,
+  setRouteFactsStore
+} from "./chunk-SNVPTULL.js";
+import "./chunk-JRPJM2XY.js";
+import "./chunk-CCATPVTW.js";
+import "./chunk-HT6KKX6A.js";
+import "./chunk-NQE46AZN.js";
+import "./chunk-2HFY3DQT.js";
+import "./chunk-4P5CMIYT.js";
+import "./chunk-FTJVHFWD.js";
+import "./chunk-3UPROT2C.js";
+export {
+  addClientEntryReason,
+  assertNoServerActionsWithoutCompat,
+  collectFileCss,
+  collectNotFoundCss,
+  findConventionFiles,
+  findGlobalError,
+  findLayouts,
+  matchInterception,
+  matchRoute,
+  materializeRouteFacts,
+  materializeRouteFactsPaced,
+  normalizePathname,
+  parseNavState,
+  routeFactsResolved,
+  routeFactsVersion,
+  scanRoutes,
+  selectRouteForRequest,
+  serverActionsUnsupportedMessage,
+  setRouteFactsStore
+};

package/dist/dash/server/bundle-0.1.5-1508b6c99c0d1e68/tsconfig-defaults-ZXEH7RQK.js

@@ -0,0 +1,13 @@
+import { createRequire as __pnextCreateRequire } from "node:module";
+const require = __pnextCreateRequire("file:///Users/muzam/Code/workshop/coder-workspace/node_modules/.bun/@wular+pnext@0.1.5+62547eec5a2188e3/node_modules/@wular/pnext/package.json");
+import {
+  writeTsconfigDefaults
+} from "./chunk-T3QZT3PG.js";
+import "./chunk-2ICEVELW.js";
+import "./chunk-5RDEILQB.js";
+import "./chunk-2HFY3DQT.js";
+import "./chunk-FTJVHFWD.js";
+import "./chunk-3UPROT2C.js";
+export {
+  writeTsconfigDefaults
+};

package/dist/default-Bobztoxf.js

@@ -0,0 +1 @@
+import{xt as e}from"./dispatch-BKeAch9E.js";import{i as t,t as n}from"./cli-BilSDkvE.js";import{runnerOptions as r}from"./remove-B93LNkZI.js";import i from"node:process";const a=t({name:`runner default`,globalFlags:{cwd:!1},args:1,help:{usage:`coder runner default <id> [--server [url]] [--json]`,summary:`Use this runner by default within its scope.`,flags:[n]},options:r,async run({options:t,args:[n]}){if(!n)throw new e(`invalid-option`,`Missing runner id.`);let{updateRunner:r}=await import(`./runner-sUpWJ_k0.js`).then(e=>e.a);return r(n,{default:!0},t)},print:e=>i.stdout.write(`Default runner ${e.name}.\n`)});export{a as commandRunnerDefault};

package/dist/default-vYPT26DR.js

@@ -0,0 +1 @@
+import{i as e,t}from"./cli-BilSDkvE.js";import{p as n}from"./output-BKeyLbvt.js";import{credentialOptions as r,missingLabel as i}from"./remove-eQ8y5C5p.js";import a from"node:process";const o=e({name:`credentials default`,globalFlags:{cwd:!1},help:{usage:`coder credentials default <label> [--workspace] [--server [url]] [--json]`,flags:[[`--workspace`,`the workspace credential of that label`],t]},options:r,args:1,async run({options:e,args:[t]}){let{connect:n}=await import(`./remote-miQNTVRa.js`).then(e=>e.a);if(!t)throw i();return n(e).credentials.setDefault(t,e)},print:(e,{args:[t]})=>a.stdout.write(`Made default ${n.bold(t)}.\n`)});export{o as commandCredentialsDefault};

package/dist/delete-D8gEwoOj.js

@@ -0,0 +1,4 @@
+import{i as e}from"./cli-BilSDkvE.js";import{p as t}from"./output-BKeyLbvt.js";import{n,t as r}from"./args-BOEEdpWk.js";import{plural as i}from"./archive-BziJ1rQ-.js";import a from"node:process";const o=e({name:`flow delete`,help:{usage:`coder flow delete <run-id> | coder flow delete --all-archived`,summary:`Delete a flow run's record from disk (its journal, events, and logs). This is
+permanent; the run's tasks are ordinary tasks and are not touched. Pass
+--all-archived to delete every archived run at once. A running run must be
+stopped first.`,flags:[[`--all-archived`,`delete every archived run`]]},options:{...r,"all-archived":n},args:1,run:async({options:e,args:[t]})=>{let{deleteRuns:n}=await import(`./executor-BvAA7Cgw.js`).then(e=>e.y);return n(t,{allArchived:e[`all-archived`]})},print(e){if(!(`count`in e))return void a.stdout.write(`Deleted run ${t.cyan(e.runId)}.\n`);a.stdout.write(e.count?`Deleted ${e.count} archived run${i(e.count)}.\n`:`${t.dim(`No archived runs to delete.`)}\n`)}});export{o as commandDelete};

package/dist/delete-z1_86nf6.js

@@ -0,0 +1,2 @@
+import{i as e,r as t}from"./cli-BilSDkvE.js";import{p as n}from"./output-BKeyLbvt.js";import{i as r,n as i,s as a,t as o}from"./args-BOEEdpWk.js";import{plural as s}from"./archive-BUB8gFKD.js";import c from"node:process";const l={server:r,workspace:a,yes:i},u=e({name:`task delete`,help:{usage:`coder task delete <task-id> | coder task delete --all-archived [--server [url]]`,summary:`Delete a task's session from disk. This is permanent. Pass --all-archived to
+delete every archived task at once. A running task must be stopped first.`,flags:[[`--all-archived`,`delete every archived task`],t]},options:{...o,"all-archived":i,...l},args:1,run:async({options:e,args:[t]})=>{let{tasks:n}=await import(`./task-C6VAg5WU.js`).then(e=>e.t);return n.delete(t,{...e,organization:e.workspace,allArchived:e[`all-archived`]})},print(e,{options:t}){if(e.count===void 0)return void c.stdout.write(`Deleted task ${n.cyan(e.taskId)}.\n`);c.stdout.write(t.server===void 0?e.count?`Deleted ${e.count} archived task${s(e.count)}.\n`:`${n.dim(`No archived tasks to delete.`)}\n`:`Deleted ${e.count} server task${s(e.count)}.\n`)}});export{u as commandDelete};

package/dist/disable-DVKd-0Xb.js

@@ -0,0 +1 @@
+import{i as e}from"./cli-BilSDkvE.js";import{a as t}from"./models-_5LVGC3m.js";import{n}from"./add-U-pty9qJ.js";import{t as r}from"./remove-C5_xggx7.js";const i=(i,a)=>e({name:`model ${i?`disable`:`enable`}`,help:a,options:n,args:1,run:({options:e,args:[n],cwd:r})=>t(r,n,i,e),json:({name:e,file:t})=>({[i?`disabled`:`enabled`]:e,file:t}),print:({name:e,file:t})=>r(i?`disabled`:`enabled`,e,t)}),a=i(!0,{usage:`coder model disable <name> [--workspace]`,summary:`Disable a model - built-in, custom, or alias. Requests for it fail until re-enabled.`,flags:[[`--workspace`,`target <repo>/.coder/config.json instead of the user file`]]});export{a as commandModelDisable,i as toggle};

package/dist/discover-Df-a8K4R.js

@@ -0,0 +1,3 @@
+import{i as e}from"./cli-BilSDkvE.js";import{g as t,p as n,s as r}from"./output-BKeyLbvt.js";import{t as i}from"./args-BOEEdpWk.js";import a from"node:path";import o from"node:process";import s from"node:os";const c=e({name:`flow discover`,help:{usage:`coder flow discover [--json]`,summary:`List every flow discoverable from the current directory: workspace flows in
+.coder/flows/ (walking up to the repo root) and global flows in ~/.coder/flows/.`},options:i,run:async({cwd:e})=>{let{discoverFlows:t}=await import(`./discover-Dvr_3_Xr.js`).then(e=>e.r);return t(e)},print:(e,{cwd:t})=>l(e,t)});function l(e,i){if(!e.length){o.stdout.write(`No flows found in .coder/flows/ (workspace) or ~/.coder/flows/ (global).
+`),o.stdout.write(`\n${r([`Authoring guide: coder docs flows`],n)}\n`);return}let c=n;o.stdout.write(t([{header:`name`,value:e=>e.name,paint:e=>c.cyan(e)},{header:`scope`,value:e=>e.scope,paint:e=>c.light(e)},{header:`path`,value:e=>e.scope===`workspace`?a.relative(i,e.path)||e.path:e.path.replace(s.homedir(),`~`),paint:e=>c.light(e)}],e,c)),o.stdout.write(`\n${r([`Run one: coder flow run <name>`,`Recent runs: coder flow list`],c)}\n`)}export{c as commandDiscover};

package/dist/discover-Dvr_3_Xr.js

@@ -0,0 +1 @@
+import{t as e}from"./rolldown-runtime-DT7IzrpZ.js";import{At as t,tn as n}from"./dispatch-BKeAch9E.js";import r from"node:path";import{fileURLToPath as i}from"node:url";import a from"node:fs";var o=e({builtinFlowsDir:()=>c,discoverFlows:()=>d,flowsIn:()=>l,resolveFlow:()=>p});const s=[`.ts`,`.mjs`,`.js`];function c(){let e=r.dirname(i(import.meta.url)),t=e;for(;r.basename(t)!==`dist`&&r.dirname(t)!==t;)t=r.dirname(t);return r.basename(t)===`dist`?r.join(t,`flow`,`builtin`):r.join(e,`builtin`)}function l(e,t){let n=[];try{n=a.readdirSync(e)}catch{return[]}let i=[];for(let o of n.sort()){let n=r.extname(o);if(s.includes(n)&&!o.endsWith(`.d.ts`)){i.push({name:r.basename(o,n),path:r.join(e,o),scope:t});continue}let c=s.map(t=>r.join(e,o,`index${t}`)).find(e=>a.existsSync(e));c&&i.push({name:o,path:c,scope:t})}return i}function u(e){let i=n(e),a=[],o=r.resolve(e);for(;a.push({dir:r.join(o,`.coder`,`flows`),scope:`workspace`}),o!==i&&r.dirname(o)!==o;)o=r.dirname(o);return a.push({dir:t(`flows`),scope:`global`}),a}function d(e){let t=new Set,n=[];for(let{dir:r,scope:i}of u(e))for(let e of l(r,i))t.has(e.name)||(t.add(e.name),n.push(e));for(let e of l(c(),`builtin`))t.has(e.name)||n.push(e);return n}function f(e){return e.includes(`/`)||s.includes(r.extname(e))}function p(e,t){if(f(e)){let n=r.resolve(t,e);if(a.existsSync(n))return{name:r.basename(n,r.extname(n)),path:n};throw Error(`Flow file not found: ${e}`)}let n=d(t).find(t=>t.name===e);if(!n)throw Error(`No flow named "${e}". Run \`coder flow discover\` to see available flows.`);return{name:n.name,path:n.path,scope:n.scope}}export{p as a,l as i,d as n,o as r,c as t};