@publish.os/nextjs 0.0.1-alpha.81 → 0.0.1-alpha.91

package/compiler-assets/nextjs/shims/site-mdx-components.tsx

@@ -0,0 +1,112 @@
+import type { MDXComponents } from "@publish.os/nextjs/mdx/mdx";
+import {
+  Figure as PublishOsFigure,
+  Image as PublishOsImage,
+  Link as PublishOsLink,
+  Video as PublishOsVideo,
+} from "@publish.os/nextjs/mdx/mdx";
+import { mediaManifest } from "@source/.publishos/media-manifest.generated";
+import {
+  mediaOverrides,
+  sourceMdxComponents,
+} from "@source/_internal/mdx-source-components.generated";
+import type { ComponentProps } from "react";
+
+type ImageProps = ComponentProps<typeof PublishOsImage>;
+type LinkProps = ComponentProps<typeof PublishOsLink>;
+type VideoProps = ComponentProps<typeof PublishOsVideo>;
+type ResolvedMediaAsset = {
+  aspect?: number;
+  height?: number;
+  intrinsicHeight?: number;
+  intrinsicWidth?: number;
+  mediaType: string;
+  mimeType?: string;
+  optimized?: boolean;
+  outputPath: string;
+  width?: number;
+};
+
+const sourceMedia = mediaOverrides as MDXComponents;
+const LinkComponent = (sourceMedia.link ??
+  PublishOsLink) as typeof PublishOsLink;
+const ImageComponent = (sourceMedia.image ??
+  PublishOsImage) as typeof PublishOsImage;
+const VideoComponent = (sourceMedia.video ??
+  PublishOsVideo) as typeof PublishOsVideo;
+const FigureComponent = (sourceMedia.figure ??
+  PublishOsFigure) as typeof PublishOsFigure;
+
+function getMediaMetadata(src: unknown): ResolvedMediaAsset | undefined {
+  if (typeof src !== "string") return undefined;
+  const pathname = src.split(/[?#]/u, 1)[0];
+  if (!pathname?.startsWith("/publishos/assets/")) return undefined;
+  return Object.values(
+    mediaManifest.assets as Record<string, ResolvedMediaAsset>,
+  ).find((asset) => asset.outputPath === pathname);
+}
+
+function authoredDimension(value: unknown): number | undefined {
+  if (typeof value === "number") return value;
+  if (typeof value !== "string" || !/^\d+$/u.test(value)) return undefined;
+  const dimension = Number(value);
+  return Number.isSafeInteger(dimension) && dimension > 0
+    ? dimension
+    : undefined;
+}
+
+function Link(props: LinkProps) {
+  const asset = getMediaMetadata(props.href);
+  const shouldDownload =
+    asset?.mediaType === "document" || asset?.mediaType === "file";
+  return (
+    <LinkComponent
+      {...props}
+      download={props.download ?? (shouldDownload ? "" : undefined)}
+      href={props.href}
+    />
+  );
+}
+
+function Image(props: ImageProps) {
+  const asset = getMediaMetadata(props.src);
+  const width = authoredDimension(props.width);
+  const height = authoredDimension(props.height);
+  return (
+    <ImageComponent
+      {...props}
+      aspect={props.aspect ?? asset?.aspect}
+      height={height ?? asset?.height}
+      intrinsicHeight={asset?.intrinsicHeight ?? asset?.height}
+      intrinsicWidth={asset?.intrinsicWidth ?? asset?.width}
+      optimized={props.optimized ?? asset?.optimized}
+      src={props.src}
+      width={width ?? asset?.width}
+    />
+  );
+}
+
+function Video(props: VideoProps) {
+  const asset = getMediaMetadata(props.src);
+  return (
+    <VideoComponent
+      {...props}
+      height={props.height ?? asset?.height}
+      poster={props.poster}
+      src={props.src}
+      width={props.width ?? asset?.width}
+    />
+  );
+}
+
+export const mdxComponents = {
+  ...sourceMdxComponents,
+  a: Link,
+  Link,
+  img: Image,
+  Image,
+  figure: FigureComponent,
+  Figure: FigureComponent,
+  video: Video,
+  Video,
+} satisfies MDXComponents;

package/compiler-assets/nextjs/shims/site-mdx.tsx

@@ -0,0 +1,17 @@
+import type { MDXProps } from "@publish.os/nextjs/mdx/mdx";
+import { renderMdx } from "@publish.os/nextjs/mdx/mdx";
+import { mdxComponents } from "@source/_internal/mdx-components.generated";
+import { importedMdxComponents } from "@source/_internal/mdx-icon-components.generated";
+
+export type { MDXComponents, MDXProps } from "@publish.os/nextjs/mdx/mdx";
+export { Figure, Image, Link, Video } from "@publish.os/nextjs/mdx/mdx";
+
+export async function MDX(props: MDXProps) {
+  return renderMdx({
+    ...props,
+    siteComponents: mdxComponents,
+    importedComponents: importedMdxComponents[props.page.path],
+  });
+}
+
+Object.defineProperty(MDX, "__publishOsMdx", { value: true });

package/compiler-assets/nextjs/shims/theme-defaults.css

@@ -4,18 +4,18 @@
   --surface-2: var(--neutral-200);
   --surface-3: var(--neutral-300);
   --surface-4: var(--neutral-400);
-  --surface-hover: var(--surface-3);
-  --surface-active: var(--surface-4);
+  --surface-hover: color-mix(in oklab, var(--foreground-1) 4%, transparent);
+  --surface-active: color-mix(in oklab, var(--foreground-1) 7%, transparent);
 
   --foreground-1: var(--neutral-1200);
   --foreground-2: var(--neutral-1100);
   --foreground-3: var(--neutral-1000);
   --foreground-4: var(--neutral-800);
 
-  --stroke-1: var(--neutral-800);
-  --stroke-2: var(--neutral-700);
-  --stroke-3: var(--neutral-500);
-  --stroke-4: var(--neutral-400);
+  --stroke-1: color-mix(in oklab, var(--foreground-1) 32%, transparent);
+  --stroke-2: color-mix(in oklab, var(--foreground-1) 18%, transparent);
+  --stroke-3: color-mix(in oklab, var(--foreground-1) 10%, transparent);
+  --stroke-4: color-mix(in oklab, var(--foreground-1) 6%, transparent);
   --backdrop: rgb(0 0 0 / 72%);
 
   --accent-1: var(--accent);
@@ -24,9 +24,17 @@
   --accent-4: color-mix(in oklch, var(--accent) 6%, transparent);
   /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
   --accent-foreground: contrast-color(var(--accent-1));
+  /* Keep accent text vivid, not mixed with gray. Scale chroma with lightness
+     when darkening to avoid clipping saturated accents outside sRGB. */
+  --accent-text-foreground: light-dark(
+    oklch(
+      from var(--accent-1) min(l, 0.5) calc(c * min(1, 0.5 / max(l, 0.001))) h
+    ),
+    oklch(from var(--accent-1) max(l, 0.72) c h)
+  );
 
   --accent-1-foreground: var(--accent-foreground);
-  --accent-1-stroke: var(--accent-1);
+  --accent-1-stroke: color-mix(in oklch, var(--accent-1) 85%, transparent);
   --accent-1-hover: oklch(
     from var(--accent-1) calc(l - 0.025) calc(c * 1.02) h
   );
@@ -36,25 +44,25 @@
 
   /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
   --accent-2-foreground: contrast-color(var(--accent-2));
-  --accent-2-stroke: color-mix(in oklch, var(--accent-2) 70%, var(--accent));
-  --accent-2-hover: color-mix(in oklch, var(--accent-2) 75%, var(--accent));
-  --accent-2-active: color-mix(in oklch, var(--accent-2) 60%, var(--accent));
+  --accent-2-stroke: oklch(from var(--accent-2) l c h / 0.3);
+  --accent-2-hover: oklch(from var(--accent-2) l c h / 0.24);
+  --accent-2-active: oklch(from var(--accent-2) l c h / 0.3);
 
   /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
   --accent-3-foreground: contrast-color(var(--accent-3));
-  --accent-3-stroke: color-mix(in oklch, var(--accent-3) 55%, var(--accent));
-  --accent-3-hover: color-mix(in oklch, var(--accent-3) 75%, var(--accent));
-  --accent-3-active: color-mix(in oklch, var(--accent-3) 60%, var(--accent));
+  --accent-3-stroke: oklch(from var(--accent-3) l c h / 0.2);
+  --accent-3-hover: oklch(from var(--accent-3) l c h / 0.18);
+  --accent-3-active: oklch(from var(--accent-3) l c h / 0.24);
 
   /* biome-ignore lint/correctness/noUnknownFunction: CSS Color 5. */
   --accent-4-foreground: contrast-color(var(--accent-4));
-  --accent-4-stroke: color-mix(in oklch, var(--accent-4) 45%, var(--accent));
-  --accent-4-hover: color-mix(in oklch, var(--accent-4) 70%, var(--accent));
-  --accent-4-active: color-mix(in oklch, var(--accent-4) 55%, var(--accent));
+  --accent-4-stroke: oklch(from var(--accent-4) l c h / 0.12);
+  --accent-4-hover: oklch(from var(--accent-4) l c h / 0.1);
+  --accent-4-active: oklch(from var(--accent-4) l c h / 0.14);
 
-  --focus-stroke: var(--accent-3-stroke);
-  --selection-surface: var(--accent-2-active);
-  --selection-foreground: var(--foreground-1);
+  --focus-stroke: var(--accent-1);
+  --selection-surface: color-mix(in oklch, var(--accent-1) 12%, transparent);
+  --selection-foreground: var(--accent-1);
   --progress-track-surface: transparent;
   --progress-indicator-surface: var(--accent-1);
   --progress-height: 2px;
@@ -150,12 +158,20 @@
   --typography-quote-foreground: var(--foreground-2);
   --typography-quote-stroke: var(--stroke-4);
   --typography-caption-foreground: var(--foreground-4);
-  --typography-code-foreground: var(--foreground-1);
-  --typography-code-surface: var(--surface-2);
-  --typography-code-stroke: var(--stroke-2);
+  --typography-code-foreground: var(--accent-text-foreground);
+  --typography-code-surface: color-mix(
+    in oklch,
+    var(--accent-1) 8%,
+    transparent
+  );
+  --typography-code-stroke: color-mix(
+    in oklch,
+    var(--accent-1) 20%,
+    transparent
+  );
   --typography-variable-foreground: var(--accent-1);
   --typography-pre-foreground: var(--foreground-2);
-  --typography-pre-surface: var(--surface-3);
+  --typography-pre-surface: var(--surface-1);
   --typography-pre-stroke: var(--stroke-3);
   --typography-table-heading-stroke: var(--stroke-3);
   --typography-table-cell-stroke: var(--stroke-4);
@@ -164,8 +180,8 @@
 
   --floating-surface-1: var(--surface-1);
   --floating-surface-2: var(--surface-2);
-  --floating-surface-3: var(--surface-3);
-  --floating-surface-4: var(--surface-4);
+  --floating-surface-3: var(--surface-hover);
+  --floating-surface-4: var(--surface-active);
   --floating-foreground-1: var(--foreground-1);
   --floating-foreground-2: var(--foreground-2);
   --floating-foreground-3: var(--foreground-3);

package/dist/build-operation-5QMLXF7N.js

@@ -0,0 +1,89 @@
+import {
+  approveLocalComposition,
+  installLocalApp
+} from "./chunk-4BC2L2KA.js";
+import {
+  withLocalOperation
+} from "./chunk-IL4RJOKI.js";
+import {
+  prepareIdeSupport
+} from "./chunk-GBPLER5H.js";
+import "./chunk-6D2E6UMD.js";
+import {
+  composeFrameworkSource
+} from "./chunk-OXOFRXEI.js";
+import {
+  validateLocalSource
+} from "./chunk-ORIUWJBQ.js";
+import "./chunk-NNBJZPFM.js";
+import "./chunk-F3AGNDF4.js";
+import "./chunk-7NY22B5U.js";
+import "./chunk-UYGCOWRF.js";
+import "./chunk-EFO6AWXN.js";
+import "./chunk-5KAD7W53.js";
+import "./chunk-WL75GQ5M.js";
+import "./chunk-AI2UULNX.js";
+import "./chunk-5J3YUNRY.js";
+import "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/build-operation.ts
+async function runLocalBuild(options) {
+  return withLocalOperation({
+    sourceRoot: options.request.paths.source,
+    outputDir: options.request.paths.output,
+    operation: "build",
+    signal: options.signal,
+    run: async (lifetime) => {
+      let { source, framework } = await validateLocalSource({
+        options,
+        sourceDir: lifetime.sourceDir,
+        sourceRoot: lifetime.sourceRoot
+      });
+      return await approveLocalComposition({ options }), options.request.context?.ide && await prepareIdeSupport({
+        frameworkOptions: { ...options, signal: lifetime.signal },
+        publishOsDir: lifetime.sourceRoot,
+        source,
+        framework
+      }), await lifetime.replaceOutput(async (outputDir) => {
+        await composeFrameworkSource({
+          request: {
+            ...options.request,
+            paths: {
+              source: lifetime.sourceDir,
+              originalSource: lifetime.sourceRoot,
+              output: outputDir
+            },
+            context: {
+              ...options.request.context,
+              previewUrl: void 0,
+              sourceRevision: lifetime.sourceRevision,
+              sourcePath: options.request.context?.sourcePath ?? "publish.os"
+            }
+          },
+          source,
+          signal: lifetime.signal,
+          onProgress: (message) => options.onEvent?.({ type: "progress", message }),
+          onWarning: (warning) => options.onEvent?.({
+            type: "diagnostics",
+            diagnostics: {
+              diagnostics: [{ ...warning, severity: "warning" }]
+            }
+          })
+        });
+        let app = await installLocalApp({
+          outputDir,
+          framework,
+          options,
+          lifetime
+        });
+        options.onEvent?.({
+          type: "progress",
+          message: "Building production output"
+        }), await app.run(["run", "build"]);
+      }), { status: "success", type: "result" };
+    }
+  });
+}
+export {
+  runLocalBuild
+};

package/dist/{button-CFdx-ohV.d.ts → button-BdCScEKi.d.ts}

@@ -1,11 +1,11 @@
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
-import { ReactNode, ButtonHTMLAttributes } from 'react';
+import { ReactNode, ComponentPropsWithRef } from 'react';
 
 declare const buttonVariants: (props?: ({
-    variant?: "solid" | "soft" | "outline" | "ghost" | null | undefined;
-    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
-    iconOnly?: boolean | null | undefined;
+    readonly variant?: "solid" | "soft" | "outline" | "ghost" | null | undefined;
+    readonly size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    readonly iconOnly?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 type ButtonVariantProps = VariantProps<typeof buttonVariants>;
 type ButtonProps = {
@@ -15,6 +15,6 @@ type ButtonProps = {
     leftIcon?: ReactNode;
     loading?: boolean;
     rightIcon?: ReactNode;
-} & ButtonVariantProps & Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children" | "className">;
+} & ButtonVariantProps & Omit<ComponentPropsWithRef<"button">, "children" | "className">;
 
-export type { ButtonVariantProps as B, ButtonProps as a };
+export type { ButtonProps as B, ButtonVariantProps as a };

package/dist/capture-local-source-WGGDIUU2.js

@@ -0,0 +1,258 @@
+import {
+  assertPublishOsSourceBoundary
+} from "./chunk-7NY22B5U.js";
+import {
+  decodeCssPath,
+  ignoredMediaDocumentWarning,
+  mediaFileByteLimit,
+  readBoundedMediaFile,
+  themeResourceByteLimit
+} from "./chunk-5KAD7W53.js";
+import {
+  isExcludedSourcePath
+} from "./chunk-WL75GQ5M.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/capture-local-source.ts
+import { createHash } from "crypto";
+import { constants } from "fs";
+import {
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  readFile,
+  realpath,
+  writeFile
+} from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import valueParser from "postcss-value-parser";
+function isInside({ root, path }) {
+  let value = relative(root, path);
+  return value !== "" && value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
+}
+function cssResourcePaths(css) {
+  let paths = /* @__PURE__ */ new Set();
+  return valueParser(css).walk((node) => {
+    if (node.type !== "function") return;
+    let name = node.value.toLowerCase(), candidates = name === "url" ? node.nodes.filter(
+      (child) => child.type === "string" || child.type === "word"
+    ) : ["image-set", "-webkit-image-set"].includes(name) ? node.nodes.filter((child) => child.type === "string") : [];
+    for (let candidate of candidates) {
+      let decoded = decodeCssPath(candidate.value.trim());
+      if (!decoded || decoded.startsWith("#") || decoded.startsWith("/") || decoded.startsWith("//") || /^[a-z][a-z0-9+.-]*:/iu.test(decoded))
+        continue;
+      let path = decoded.split(/[?#]/u, 1)[0] ?? "";
+      path && paths.add(path);
+    }
+    if (name === "url") return !1;
+  }), [...paths];
+}
+async function collectCssReferencedResources({
+  captureDir,
+  capturedFiles
+}) {
+  let referenced = /* @__PURE__ */ new Set();
+  for (let cssFile of capturedFiles.filter(
+    (path) => path.toLowerCase().endsWith(".css")
+  )) {
+    let css = await readFile(join(captureDir, cssFile), "utf8");
+    for (let urlPath of cssResourcePaths(css)) {
+      let absolutePath = resolve(captureDir, dirname(cssFile), urlPath);
+      isInside({ root: captureDir, path: absolutePath }) && referenced.add(relative(captureDir, absolutePath).split(sep).join("/"));
+    }
+  }
+  return referenced;
+}
+function localFontPaths(config) {
+  if (!config || typeof config != "object" || Array.isArray(config)) return [];
+  let fonts = config.fonts;
+  if (!fonts || typeof fonts != "object" || Array.isArray(fonts)) return [];
+  let paths = /* @__PURE__ */ new Set();
+  for (let role of Object.values(fonts)) {
+    if (!role || typeof role != "object" || Array.isArray(role)) continue;
+    let src = role.src, addPath = (value) => {
+      if (typeof value != "string" || /^[a-z][a-z0-9+.-]*:/iu.test(value) || value.startsWith("//") || value.includes("\0"))
+        return;
+      let normalized = value.replace(/^\/+/, "").replace(/^\.\//, "");
+      normalized && paths.add(normalized);
+    };
+    if (addPath(src), Array.isArray(src))
+      for (let file of src)
+        file && typeof file == "object" && !Array.isArray(file) && addPath(file.path);
+  }
+  return [...paths];
+}
+async function collectConfiguredFontResources({
+  captureDir,
+  capturedFiles
+}) {
+  let referenced = /* @__PURE__ */ new Set();
+  for (let configPath of capturedFiles.filter(
+    (path) => path.endsWith(".config.json")
+  )) {
+    let config;
+    try {
+      config = JSON.parse(await readFile(join(captureDir, configPath), "utf8"));
+    } catch {
+      continue;
+    }
+    for (let fontPath of localFontPaths(config)) {
+      let absolutePath = resolve(captureDir, fontPath);
+      isInside({ root: captureDir, path: absolutePath }) && referenced.add(relative(captureDir, absolutePath).split(sep).join("/"));
+    }
+  }
+  return referenced;
+}
+async function readUnboundedSourceFile({
+  path,
+  entry,
+  signal
+}) {
+  let file = await open(
+    path,
+    constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0)
+  );
+  try {
+    let opened = await file.stat();
+    if (!opened.isFile() || opened.dev !== entry.dev || opened.ino !== entry.ino)
+      throw new AppError({
+        code: "FRAMEWORK_CAPTURE_SOURCE_CHANGED",
+        message: "A source entry changed before capture could read it."
+      });
+    signal?.throwIfAborted();
+    let contents = await file.readFile({ signal });
+    return signal?.throwIfAborted(), contents;
+  } finally {
+    await file.close();
+  }
+}
+async function captureLocalSource({
+  sourceRoot,
+  captureDir,
+  signal
+}) {
+  signal?.throwIfAborted(), await assertPublishOsSourceBoundary(sourceRoot), signal?.throwIfAborted();
+  let root = await realpath(sourceRoot), destination = resolve(captureDir), outputRoot = join(root, ".publish.os");
+  if (!isInside({ root: outputRoot, path: destination }) || await realpath(dirname(destination)) !== dirname(destination))
+    throw new AppError({
+      code: "FRAMEWORK_CAPTURE_OUTPUT_INVALID",
+      message: "Source capture requires an owned path inside source output."
+    });
+  await mkdir(destination).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let destinationEntry = await lstat(destination);
+  if (!destinationEntry.isDirectory() || destinationEntry.isSymbolicLink() || await realpath(destination) !== destination || (await readdir(destination)).length > 0)
+    throw new AppError({
+      code: "FRAMEWORK_CAPTURE_OUTPUT_INVALID",
+      message: "Source capture requires an empty owned directory."
+    });
+  let capturedFiles = [], deferredResources = [], copyDirectory = async (relativeDirectory) => {
+    signal?.throwIfAborted();
+    let directory = join(root, relativeDirectory), names = (await readdir(directory)).sort();
+    if (!relativeDirectory) {
+      let configIndex = names.indexOf("publish.os.config.json");
+      if (configIndex > 0) {
+        let [configName] = names.splice(configIndex, 1);
+        configName && names.unshift(configName);
+      }
+    }
+    for (let name of names) {
+      signal?.throwIfAborted();
+      let path = relativeDirectory ? `${relativeDirectory}/${name}` : name;
+      if (isExcludedSourcePath(path) || relativeDirectory === "" && name.startsWith(".env"))
+        continue;
+      let sourcePath = join(root, path), outputPath = join(destination, path), entry = await lstat(sourcePath);
+      if (entry.isSymbolicLink())
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_SYMLINK",
+          message: "Symbolic links are not allowed inside publish.os."
+        });
+      if (!isInside({ root, path: await realpath(sourcePath) }))
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_PATH_ESCAPE",
+          message: "A source entry resolves outside the selected source."
+        });
+      if (entry.isDirectory()) {
+        await mkdir(outputPath), await copyDirectory(path);
+        continue;
+      }
+      if (!entry.isFile())
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_ENTRY_NOT_REGULAR",
+          message: "Source capture accepts only directories and regular files."
+        });
+      let contents;
+      if (ignoredMediaDocumentWarning(path))
+        contents = Buffer.alloc(0);
+      else if (path.startsWith("assets/")) {
+        let relativeAssetPath = path.slice(7);
+        contents = await readBoundedMediaFile({
+          path: sourcePath,
+          relativePath: `assets/${relativeAssetPath}`,
+          limit: mediaFileByteLimit(relativeAssetPath),
+          expectedIdentity: { dev: entry.dev, ino: entry.ino },
+          signal
+        });
+      } else if (themeResourceByteLimit(path) !== void 0) {
+        deferredResources.push({
+          path: sourcePath,
+          outputPath,
+          relativePath: path,
+          entry
+        });
+        continue;
+      } else
+        contents = await readUnboundedSourceFile({
+          path: sourcePath,
+          entry,
+          signal
+        });
+      await writeFile(outputPath, contents, { flag: "wx", signal }), capturedFiles.push(path);
+    }
+  };
+  await copyDirectory("");
+  let cssResources = await collectCssReferencedResources({
+    captureDir: destination,
+    capturedFiles
+  });
+  for (let path of await collectConfiguredFontResources({
+    captureDir: destination,
+    capturedFiles
+  }))
+    cssResources.add(path);
+  for (let resource of deferredResources) {
+    signal?.throwIfAborted();
+    let contents = cssResources.has(resource.relativePath) ? await readBoundedMediaFile({
+      path: resource.path,
+      relativePath: resource.relativePath,
+      limit: themeResourceByteLimit(resource.relativePath) ?? 0,
+      expectedIdentity: {
+        dev: resource.entry.dev,
+        ino: resource.entry.ino
+      },
+      signal
+    }) : await readUnboundedSourceFile({
+      path: resource.path,
+      entry: resource.entry,
+      signal
+    });
+    await writeFile(resource.outputPath, contents, { flag: "wx", signal }), capturedFiles.push(resource.relativePath);
+  }
+  let hash = createHash("sha256");
+  for (let path of capturedFiles.sort()) {
+    signal?.throwIfAborted();
+    let contents = await readFile(join(destination, path), { signal });
+    hash.update(JSON.stringify([path, contents.byteLength])), hash.update("\0"), hash.update(contents);
+  }
+  return signal?.throwIfAborted(), {
+    sourceDir: captureDir,
+    sourceRevision: `sha256:${hash.digest("hex")}`
+  };
+}
+export {
+  captureLocalSource
+};

package/dist/chunk-22RSSUNV.js

@@ -0,0 +1,13 @@
+// src/lib/compiler/internal/errors.ts
+var AppError = class extends Error {
+  code;
+  details;
+  fix;
+  constructor({ code, message, details, fix }) {
+    super(message), this.name = "FrameworkError", this.code = code, this.details = details, this.fix = fix;
+  }
+};
+
+export {
+  AppError
+};