@depths/waves 0.1.0

package/dist/chunk-TGAL5RQN.mjs

@@ -0,0 +1,404 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/json-schema.ts
+import { z } from "zod";
+function zodSchemaToJsonSchema(schema) {
+  return z.toJSONSchema(schema);
+}
+
+// src/ir/schema.ts
+import { z as z2 } from "zod";
+var TimingSpecSchema = z2.object({
+  from: z2.number().int().min(0).describe("Start frame (0-indexed)"),
+  durationInFrames: z2.number().int().positive().describe("Duration in frames")
+});
+var AssetPathSchema = z2.string().refine(
+  (path) => path.startsWith("/") || path.startsWith("http://") || path.startsWith("https://"),
+  "Asset path must be absolute (starting with /) or a full URL"
+).describe("Path to asset file, either absolute path or URL");
+var BackgroundSpecSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("color"),
+    value: z2.string().regex(/^#[0-9A-Fa-f]{6}$/, "Must be valid hex color")
+  }),
+  z2.object({
+    type: z2.literal("image"),
+    value: AssetPathSchema
+  }),
+  z2.object({
+    type: z2.literal("video"),
+    value: AssetPathSchema
+  })
+]);
+var BaseComponentIRSchema = z2.object({
+  id: z2.string().min(1).max(100).describe("Unique component instance ID"),
+  type: z2.string().min(1).describe("Component type identifier"),
+  timing: TimingSpecSchema,
+  metadata: z2.record(z2.string(), z2.unknown()).optional().describe("Optional metadata")
+});
+var TextComponentIRSchema = BaseComponentIRSchema.extend({
+  type: z2.literal("Text"),
+  props: z2.object({
+    content: z2.string().min(1).max(1e3),
+    fontSize: z2.number().int().min(12).max(200).default(48),
+    color: z2.string().regex(/^#[0-9A-Fa-f]{6}$/).default("#FFFFFF"),
+    position: z2.enum(["top", "center", "bottom", "left", "right"]).default("center"),
+    animation: z2.enum(["none", "fade", "slide", "zoom"]).default("fade")
+  })
+});
+var AudioComponentIRSchema = BaseComponentIRSchema.extend({
+  type: z2.literal("Audio"),
+  props: z2.object({
+    src: AssetPathSchema,
+    volume: z2.number().min(0).max(1).default(1),
+    startFrom: z2.number().int().min(0).default(0).describe("Start playback from frame N"),
+    fadeIn: z2.number().int().min(0).default(0).describe("Fade in duration in frames"),
+    fadeOut: z2.number().int().min(0).default(0).describe("Fade out duration in frames")
+  })
+});
+function getComponentIRSchema() {
+  return ComponentIRSchema;
+}
+var SceneComponentIRSchema = BaseComponentIRSchema.extend({
+  type: z2.literal("Scene"),
+  props: z2.object({
+    background: BackgroundSpecSchema
+  }),
+  children: z2.lazy(() => z2.array(getComponentIRSchema())).optional()
+});
+var ComponentIRSchema = z2.discriminatedUnion("type", [
+  SceneComponentIRSchema,
+  TextComponentIRSchema,
+  AudioComponentIRSchema
+]);
+var VideoIRSchema = z2.object({
+  version: z2.literal("1.0").describe("IR schema version"),
+  video: z2.object({
+    id: z2.string().default("main"),
+    width: z2.number().int().min(360).max(7680),
+    height: z2.number().int().min(360).max(4320),
+    fps: z2.number().int().min(1).max(120).default(30),
+    durationInFrames: z2.number().int().positive()
+  }),
+  audio: z2.object({
+    background: AssetPathSchema.optional(),
+    volume: z2.number().min(0).max(1).default(0.5)
+  }).optional(),
+  scenes: z2.array(SceneComponentIRSchema).min(1)
+});
+var ComponentSchemas = {
+  Scene: SceneComponentIRSchema,
+  Text: TextComponentIRSchema,
+  Audio: AudioComponentIRSchema
+};
+
+// src/core/registry.ts
+var ComponentRegistry = class {
+  components = /* @__PURE__ */ new Map();
+  register(registration) {
+    if (this.components.has(registration.type)) {
+      throw new Error(`Component type "${registration.type}" is already registered`);
+    }
+    this.components.set(registration.type, registration);
+  }
+  get(type) {
+    return this.components.get(type);
+  }
+  getTypes() {
+    return Array.from(this.components.keys());
+  }
+  has(type) {
+    return this.components.has(type);
+  }
+  getJSONSchemaForLLM() {
+    const schemas = {};
+    for (const [type, registration] of this.components) {
+      schemas[type] = {
+        schema: zodSchemaToJsonSchema(registration.propsSchema),
+        metadata: registration.metadata
+      };
+    }
+    return schemas;
+  }
+  validateProps(type, props) {
+    const registration = this.components.get(type);
+    if (!registration) {
+      throw new Error(`Unknown component type: ${type}`);
+    }
+    const result = registration.propsSchema.safeParse(props);
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+  }
+};
+var globalRegistry = new ComponentRegistry();
+
+// src/components/primitives/Audio.tsx
+import { Audio as RemotionAudio, interpolate, staticFile, useCurrentFrame } from "remotion";
+import { z as z3 } from "zod";
+
+// src/utils/assets.ts
+function isRemoteAssetPath(assetPath) {
+  return assetPath.startsWith("http://") || assetPath.startsWith("https://");
+}
+function staticFileInputFromAssetPath(assetPath) {
+  if (isRemoteAssetPath(assetPath)) {
+    throw new Error("Remote asset paths must not be passed to staticFile()");
+  }
+  return assetPath.startsWith("/") ? assetPath.slice(1) : assetPath;
+}
+
+// src/components/primitives/Audio.tsx
+import { jsx } from "react/jsx-runtime";
+var AudioPropsSchema = z3.object({
+  src: z3.string(),
+  volume: z3.number().min(0).max(1).default(1),
+  startFrom: z3.number().int().min(0).default(0),
+  fadeIn: z3.number().int().min(0).default(0),
+  fadeOut: z3.number().int().min(0).default(0)
+});
+var Audio = ({
+  src,
+  volume,
+  startFrom,
+  fadeIn,
+  fadeOut,
+  __wavesDurationInFrames
+}) => {
+  const frame = useCurrentFrame();
+  const durationInFrames = __wavesDurationInFrames ?? Number.POSITIVE_INFINITY;
+  const fadeInFactor = fadeIn > 0 ? interpolate(frame, [0, fadeIn], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const fadeOutStart = durationInFrames - fadeOut;
+  const fadeOutFactor = fadeOut > 0 ? interpolate(frame, [fadeOutStart, durationInFrames], [1, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const resolvedSrc = isRemoteAssetPath(src) ? src : staticFile(staticFileInputFromAssetPath(src));
+  return /* @__PURE__ */ jsx(
+    RemotionAudio,
+    {
+      src: resolvedSrc,
+      trimBefore: startFrom,
+      volume: volume * fadeInFactor * fadeOutFactor
+    }
+  );
+};
+var AudioComponentMetadata = {
+  category: "primitive",
+  description: "Plays an audio file with optional trimming and fade in/out",
+  llmGuidance: "Use for background music or sound effects. Prefer short clips for SFX. Use fadeIn/fadeOut (in frames) for smoother audio starts/ends."
+};
+
+// src/components/primitives/Scene.tsx
+import { AbsoluteFill, Img, Video, staticFile as staticFile2 } from "remotion";
+import { z as z4 } from "zod";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var ScenePropsSchema = z4.object({
+  background: BackgroundSpecSchema
+});
+var resolveAsset = (value) => {
+  return isRemoteAssetPath(value) ? value : staticFile2(staticFileInputFromAssetPath(value));
+};
+var Scene = ({ background, children }) => {
+  return /* @__PURE__ */ jsxs(AbsoluteFill, { children: [
+    background.type === "color" ? /* @__PURE__ */ jsx2(AbsoluteFill, { style: { backgroundColor: background.value } }) : background.type === "image" ? /* @__PURE__ */ jsx2(
+      Img,
+      {
+        src: resolveAsset(background.value),
+        style: { width: "100%", height: "100%", objectFit: "cover" }
+      }
+    ) : /* @__PURE__ */ jsx2(
+      Video,
+      {
+        src: resolveAsset(background.value),
+        style: { width: "100%", height: "100%", objectFit: "cover" }
+      }
+    ),
+    /* @__PURE__ */ jsx2(AbsoluteFill, { children })
+  ] });
+};
+var SceneComponentMetadata = {
+  category: "primitive",
+  description: "Scene container with a background and nested children",
+  llmGuidance: "Use Scene to define a segment of the video. Scene timings must be sequential with no gaps. Put Text and Audio as children."
+};
+
+// src/components/primitives/Text.tsx
+import { AbsoluteFill as AbsoluteFill2, interpolate as interpolate2, useCurrentFrame as useCurrentFrame2 } from "remotion";
+import { z as z5 } from "zod";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var TextPropsSchema = z5.object({
+  content: z5.string(),
+  fontSize: z5.number().default(48),
+  color: z5.string().default("#FFFFFF"),
+  position: z5.enum(["top", "center", "bottom", "left", "right"]).default("center"),
+  animation: z5.enum(["none", "fade", "slide", "zoom"]).default("fade")
+});
+var getPositionStyles = (position) => {
+  const base = {
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center"
+  };
+  switch (position) {
+    case "top":
+      return { ...base, alignItems: "flex-start", paddingTop: 60 };
+    case "bottom":
+      return { ...base, alignItems: "flex-end", paddingBottom: 60 };
+    case "left":
+      return { ...base, justifyContent: "flex-start", paddingLeft: 60 };
+    case "right":
+      return { ...base, justifyContent: "flex-end", paddingRight: 60 };
+    default:
+      return base;
+  }
+};
+var getAnimationStyle = (frame, animation) => {
+  const animDuration = 30;
+  switch (animation) {
+    case "fade": {
+      const opacity = interpolate2(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { opacity };
+    }
+    case "slide": {
+      const translateY = interpolate2(frame, [0, animDuration], [50, 0], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const opacity = interpolate2(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { transform: `translateY(${translateY}px)`, opacity };
+    }
+    case "zoom": {
+      const scale = interpolate2(frame, [0, animDuration], [0.8, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const opacity = interpolate2(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { transform: `scale(${scale})`, opacity };
+    }
+    default:
+      return {};
+  }
+};
+var Text = ({ content, fontSize, color, position, animation }) => {
+  const frame = useCurrentFrame2();
+  const positionStyles = getPositionStyles(position);
+  const animationStyles = getAnimationStyle(frame, animation);
+  return /* @__PURE__ */ jsx3(AbsoluteFill2, { style: positionStyles, children: /* @__PURE__ */ jsx3(
+    "div",
+    {
+      style: {
+        fontSize,
+        color,
+        fontWeight: 600,
+        textAlign: "center",
+        ...animationStyles
+      },
+      children: content
+    }
+  ) });
+};
+var TextComponentMetadata = {
+  category: "primitive",
+  description: "Displays animated text with positioning and animation options",
+  llmGuidance: 'Use for titles, subtitles, captions. Keep content under 100 characters for readability. Position "center" works best for titles.',
+  examples: [
+    {
+      content: "Welcome to Waves",
+      fontSize: 72,
+      color: "#FFFFFF",
+      position: "center",
+      animation: "fade"
+    },
+    {
+      content: "Building the future of video",
+      fontSize: 36,
+      color: "#CCCCCC",
+      position: "bottom",
+      animation: "slide"
+    }
+  ]
+};
+
+// src/components/registry.ts
+function registerBuiltInComponents() {
+  if (!globalRegistry.has("Scene")) {
+    globalRegistry.register({
+      type: "Scene",
+      component: Scene,
+      propsSchema: ScenePropsSchema,
+      metadata: SceneComponentMetadata
+    });
+  }
+  if (!globalRegistry.has("Text")) {
+    globalRegistry.register({
+      type: "Text",
+      component: Text,
+      propsSchema: TextPropsSchema,
+      metadata: TextComponentMetadata
+    });
+  }
+  if (!globalRegistry.has("Audio")) {
+    globalRegistry.register({
+      type: "Audio",
+      component: Audio,
+      propsSchema: AudioPropsSchema,
+      metadata: AudioComponentMetadata
+    });
+  }
+}
+
+// src/utils/errors.ts
+var WavesError = class _WavesError extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "WavesError";
+    Object.setPrototypeOf(this, _WavesError.prototype);
+  }
+};
+var WavesValidationError = class _WavesValidationError extends WavesError {
+  constructor(message, context) {
+    super(message, context);
+    this.name = "WavesValidationError";
+    Object.setPrototypeOf(this, _WavesValidationError.prototype);
+  }
+};
+var WavesRenderError = class _WavesRenderError extends WavesError {
+  constructor(message, context) {
+    super(message, context);
+    this.name = "WavesRenderError";
+    Object.setPrototypeOf(this, _WavesRenderError.prototype);
+  }
+};
+
+export {
+  __require,
+  zodSchemaToJsonSchema,
+  VideoIRSchema,
+  ComponentSchemas,
+  ComponentRegistry,
+  globalRegistry,
+  registerBuiltInComponents,
+  WavesError,
+  WavesValidationError,
+  WavesRenderError
+};

package/dist/chunk-WGQITADJ.mjs

@@ -0,0 +1,284 @@
+import {
+  VideoIRSchema,
+  WavesRenderError,
+  globalRegistry,
+  registerBuiltInComponents,
+  zodSchemaToJsonSchema
+} from "./chunk-TGAL5RQN.mjs";
+
+// src/version.ts
+var __wavesVersion = "0.1.0";
+
+// src/llm/prompt.ts
+var RULES = {
+  timing: [
+    "All timing is in frames (integers).",
+    "Every component has timing: { from, durationInFrames }.",
+    "Scenes must be sequential: scene[0].timing.from = 0 and each next scene starts where the previous ends (no gaps/overlaps).",
+    "Sum of all scene durations must equal video.durationInFrames.",
+    "Child components inside a Scene must fit within the Scene duration."
+  ],
+  assets: [
+    'Asset paths must be either full URLs (http:// or https://) or absolute public paths starting with "/".',
+    'When using absolute public paths ("/assets/..."), the renderer resolves them relative to the --publicDir passed at render time.'
+  ],
+  ids: [
+    "Every component must have a stable string id.",
+    "Ids should be unique within the whole IR."
+  ],
+  output: [
+    "Return only a single JSON object (no markdown fences, no commentary).",
+    "The JSON must validate against the provided JSON Schemas.",
+    'Only use component "type" values that exist in schemas.components.'
+  ]
+};
+function getSystemPrompt(registeredTypes) {
+  const typesLine = registeredTypes.length ? registeredTypes.join(", ") : "(none)";
+  return [
+    "You generate JSON for @depths/waves Video IR (version 1.0).",
+    "",
+    "Goal:",
+    "- Produce a single JSON object that conforms to the provided Video IR JSON Schema and uses only registered component types.",
+    "",
+    "Registered component types:",
+    `- ${typesLine}`,
+    "",
+    "Authoring rules:",
+    ...RULES.output.map((r) => `- ${r}`),
+    ...RULES.timing.map((r) => `- ${r}`),
+    ...RULES.assets.map((r) => `- ${r}`),
+    ...RULES.ids.map((r) => `- ${r}`),
+    "",
+    "If you are unsure about an asset, prefer a solid color Scene background and omit optional props to use defaults.",
+    ""
+  ].join("\n");
+}
+function getPromptPayload(options) {
+  registerBuiltInComponents();
+  const registry = options?.registry ?? globalRegistry;
+  const types = registry.getTypes().sort();
+  return {
+    package: "@depths/waves",
+    version: __wavesVersion,
+    irVersion: "1.0",
+    systemPrompt: getSystemPrompt(types),
+    schemas: {
+      videoIR: zodSchemaToJsonSchema(VideoIRSchema),
+      components: registry.getJSONSchemaForLLM()
+    },
+    rules: {
+      timing: [...RULES.timing],
+      assets: [...RULES.assets],
+      ids: [...RULES.ids],
+      output: [...RULES.output]
+    }
+  };
+}
+
+// src/core/validator.ts
+var IRValidator = class {
+  validateSchema(ir) {
+    const result = VideoIRSchema.safeParse(ir);
+    if (!result.success) {
+      return {
+        success: false,
+        errors: result.error.issues.map((issue) => ({
+          path: issue.path.map((p) => String(p)),
+          message: issue.message,
+          code: issue.code
+        }))
+      };
+    }
+    return { success: true, data: result.data };
+  }
+  validateSemantics(ir) {
+    const errors = [];
+    const totalSceneDuration = ir.scenes.reduce((sum, scene) => sum + scene.timing.durationInFrames, 0);
+    if (totalSceneDuration !== ir.video.durationInFrames) {
+      errors.push({
+        path: ["scenes"],
+        message: `Sum of scene durations (${totalSceneDuration}) does not match video duration (${ir.video.durationInFrames})`,
+        code: "DURATION_MISMATCH"
+      });
+    }
+    let expectedFrame = 0;
+    for (const [i, scene] of ir.scenes.entries()) {
+      if (scene.timing.from !== expectedFrame) {
+        errors.push({
+          path: ["scenes", String(i), "timing", "from"],
+          message: `Scene ${i} starts at frame ${scene.timing.from}, expected ${expectedFrame}`,
+          code: "TIMING_GAP_OR_OVERLAP"
+        });
+      }
+      expectedFrame += scene.timing.durationInFrames;
+    }
+    for (const [i, scene] of ir.scenes.entries()) {
+      if (scene.children && scene.children.length > 0) {
+        this.validateComponentTimingRecursive(
+          scene.children,
+          scene.timing.durationInFrames,
+          ["scenes", String(i)],
+          errors
+        );
+      }
+    }
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+    return { success: true };
+  }
+  validate(ir) {
+    const schemaResult = this.validateSchema(ir);
+    if (!schemaResult.success) {
+      return schemaResult;
+    }
+    const semanticsResult = this.validateSemantics(schemaResult.data);
+    if (!semanticsResult.success) {
+      return { success: false, errors: semanticsResult.errors ?? [] };
+    }
+    return schemaResult;
+  }
+  validateComponentTimingRecursive(components, parentDuration, pathPrefix, errors) {
+    for (const [i, component] of components.entries()) {
+      const componentEnd = component.timing.from + component.timing.durationInFrames;
+      if (componentEnd > parentDuration) {
+        errors.push({
+          path: [...pathPrefix, "children", String(i), "timing"],
+          message: `Component extends beyond parent duration (${componentEnd} > ${parentDuration})`,
+          code: "COMPONENT_EXCEEDS_PARENT"
+        });
+      }
+      if (component.type === "Scene" && component.children && component.children.length > 0) {
+        this.validateComponentTimingRecursive(
+          component.children,
+          component.timing.durationInFrames,
+          [...pathPrefix, "children", String(i)],
+          errors
+        );
+      }
+    }
+  }
+};
+
+// src/core/engine.ts
+import { bundle } from "@remotion/bundler";
+import { renderMedia, selectComposition } from "@remotion/renderer";
+import fs from "fs/promises";
+import path from "path";
+var WavesEngine = class {
+  constructor(registry, validator) {
+    this.registry = registry;
+    this.validator = validator;
+  }
+  async render(ir, options) {
+    if (this.registry !== globalRegistry) {
+      throw new WavesRenderError("WavesEngine currently requires using globalRegistry", {
+        hint: "Use `registerBuiltInComponents()` + `globalRegistry` for both validation and rendering."
+      });
+    }
+    const validationResult = this.validator.validate(ir);
+    if (!validationResult.success) {
+      throw new WavesRenderError("IR validation failed", { errors: validationResult.errors });
+    }
+    const validatedIR = validationResult.data;
+    const requiredTypes = collectComponentTypes(validatedIR);
+    for (const type of requiredTypes) {
+      if (!this.registry.has(type)) {
+        throw new WavesRenderError("Unknown component type", { type });
+      }
+    }
+    const rootDir = options.rootDir ?? process.cwd();
+    const tmpDir = await fs.mkdtemp(path.join(rootDir, ".waves-tmp-"));
+    const entryPoint = path.join(tmpDir, "entry.tsx");
+    try {
+      await fs.writeFile(entryPoint, generateEntryPoint(validatedIR, options), "utf-8");
+      await fs.mkdir(path.dirname(options.outputPath), { recursive: true });
+      const bundleLocation = await bundle({
+        entryPoint,
+        rootDir,
+        publicDir: options.publicDir ?? null,
+        onProgress: () => void 0
+      });
+      const compositionId = validatedIR.video.id ?? "main";
+      const composition = await selectComposition({
+        serveUrl: bundleLocation,
+        id: compositionId,
+        inputProps: {}
+      });
+      await renderMedia({
+        composition,
+        serveUrl: bundleLocation,
+        codec: options.codec ?? "h264",
+        outputLocation: options.outputPath,
+        crf: options.crf ?? null,
+        concurrency: options.concurrency ?? null,
+        overwrite: true
+      });
+    } catch (error) {
+      throw new WavesRenderError("Rendering failed", { originalError: error });
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  }
+};
+function collectComponentTypes(ir) {
+  const types = /* @__PURE__ */ new Set();
+  for (const scene of ir.scenes) {
+    walkComponent(scene, types);
+  }
+  return types;
+}
+function walkComponent(component, types) {
+  types.add(component.type);
+  const children = component.children;
+  if (children) {
+    for (const child of children) {
+      walkComponent(child, types);
+    }
+  }
+}
+function generateEntryPoint(ir, options) {
+  const compositionId = ir.video.id ?? "main";
+  const width = ir.video.width;
+  const height = ir.video.height;
+  const fps = ir.video.fps ?? 30;
+  const durationInFrames = ir.video.durationInFrames;
+  const registrationImports = (options.registrationModules ?? []).map((m) => `import ${JSON.stringify(m)};`).join("\n");
+  return `import React from 'react';
+import { Composition, registerRoot } from 'remotion';
+import { WavesComposition, globalRegistry, registerBuiltInComponents } from '@depths/waves/remotion';
+${registrationImports}
+
+registerBuiltInComponents();
+
+const ir = ${JSON.stringify(ir, null, 2)};
+const compositionId = ${JSON.stringify(compositionId)};
+
+const Root = () => {
+  return <WavesComposition ir={ir} registry={globalRegistry} />;
+};
+
+export const RemotionRoot = () => {
+  return (
+    <Composition
+      id={compositionId}
+      component={Root}
+      durationInFrames={${durationInFrames}}
+      fps={${fps}}
+      width={${width}}
+      height={${height}}
+    />
+  );
+};
+
+registerRoot(RemotionRoot);
+`;
+}
+
+export {
+  __wavesVersion,
+  getSystemPrompt,
+  getPromptPayload,
+  IRValidator,
+  WavesEngine
+};

package/dist/cli.d.mts

@@ -0,0 +1,3 @@
+declare function main(argv?: string[]): Promise<number>;
+
+export { main };

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+declare function main(argv?: string[]): Promise<number>;
+
+export { main };