tonnage 0.2.0 → 0.4.0

package/AGENTS.md

@@ -1,12 +1,13 @@
 # tonnage
 
-CI-first runtime JavaScript bundle measurement with checked-in README reports.
+Runtime JavaScript bundle measurement for Galley documents.
 
+- Install `galley.md@^0.1.1` alongside tonnage. Galley is a required peer.
+- Import `Tonnage` from `tonnage` in an MDX document. Pass measurement options through `config`, using `defineConfig` for reusable configurations if desired.
+- Paths default to the containing document's directory. Set `directory` to measure another package; relative overrides resolve from the document. Resolve `packageJson` from that directory and recipe entries from the selected manifest's directory. Imported configuration files do not change these bases.
+- Run `galley write` to generate Markdown and `galley check` in CI to detect missing or stale output. Maintain the MDX source and commit the generated Markdown.
 - Tonnage measures emitted minified JavaScript and level-9 gzip bytes. Do not include declarations, source maps, CSS, or other assets in those figures.
 - Public-module rows retain the complete runtime export surface. Recipe rows use reviewable entry files and tree-shake unused exports.
-- Treat each recipe as one realistic runtime boundary. Keep server and client recipes separate, and count shared modules once within each bundle.
+- Treat each recipe as one realistic runtime boundary. Keep server and client recipes separate, and count shared modules once per bundle.
 - Peer dependencies stay external by default. Use explicit `external` entries only for additional dependencies intentionally supplied by consumers.
-- Run `tonnage write` to update a generated README section and `tonnage check` in CI to detect drift.
-- Keep marker names stable and use the `tonnage:<name>:start` and `tonnage:<name>:end` comment forms.
-- For a galley.md document, import `Tonnage` from `tonnage/galley`. Its config paths default to the containing document's directory. The component measures and renders a report without writing a README or requiring section markers.
-- Await `renderTonnageMarkdown(report, config)` when using the programmatic API. CLI reports and document components share Galley's table rendering, escaping literal text and aligning byte columns to the right.
+- The component returns Galley elements without writing files. Its tables escape literal text and align byte columns to the right.

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # tonnage
 
+## 0.4.0
+
+### Minor Changes
+
+- fffad43: Make tonnage a Galley component package: import Tonnage from tonnage and use galley write/check to generate and validate README files from MDX. Remove the tonnage executable and shell completion, tonnage/galley subpath, marker-based README editing, marker/readme config fields, and standalone measurement, report, and rendering exports. Keep defineConfig and component configuration types; migrate existing README content to README.mdx and replace generated-section markers with a Tonnage component.
+
+## 0.3.0
+
+### Minor Changes
+
+- 02567f0: Make galley.md ^0.1.1 a required peer dependency so consumers control the Galley version used by report rendering and MDX components. Install a compatible galley.md version alongside tonnage, including for standalone CLI use.
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -1,19 +1,51 @@
 # tonnage
 
-Keep exact bundle size tables in a package README and fail CI when the checked-in
-numbers drift.
+Bundle size reports for [Galley](https://www.npmjs.com/package/galley.md) documents.
 
-The tool bundles real public package imports with esbuild, minifies the result,
-and reports JavaScript bytes before and after level-9 gzip. Public-module rows
-retain every runtime export; recipe entry files can select named exports and
-tree-shake the rest. Declarations, source maps, CSS, and other assets are not
-counted. Peer dependencies stay external, and shared modules are counted once
-per bundle.
+Tonnage bundles real public package imports with esbuild, minifies the result,
+and reports JavaScript bytes before and after level-9 gzip. Embed its component
+in a README source document, then use Galley to generate Markdown and detect
+stale reports in CI.
+
+## Install
+
+Install tonnage and its required Galley peer:
+
+```sh
+pnpm add -D tonnage 'galley.md@^0.1.1'
+```
+
+## Use
+
+Create `README.mdx` beside your package manifest:
+
+```mdx
+import { Tonnage } from "tonnage"
+
+# My package
+
+<Tonnage config={{ platform: "node" }} />
+```
+
+Run `galley write` to generate `README.md`. Run `galley check` in CI to evaluate
+the document again and exit nonzero if its output is missing or stale. Keep the
+MDX source and generated Markdown in version control.
+
+The component defaults to measuring every public export except `./package.json`.
+Paths resolve relative to the containing document. To measure another package,
+pass `directory`, such as `<Tonnage directory="../my-package" />`; relative
+values resolve from the document's directory. The `packageJson` path resolves
+from that measurement directory; recipe entry paths resolve from the selected
+manifest's directory.
+
+Galley owns document evaluation and output files. See its
+[user guide](https://github.com/jeremybanka/galley#readme) for document composition
+and command options.
 
 ## Configure
 
-Add the generated-section comments to the target README, then create a config
-beside the package manifest. The complete configuration exhibit is in
+Pass configuration inline or import a reusable configuration using `defineConfig`.
+The complete configuration exhibit is in
 [examples/tonnage.config.ts](./examples/tonnage.config.ts).
 
 ```ts
@@ -24,7 +56,6 @@ const config: TonnageConfig = defineConfig({
 	exports: {
 		exclude: [`./package.json`],
 	},
-	marker: `my-package`,
 	recipes: [
 		{
 			entry: `examples/recipes/react-app.ts`,
@@ -39,10 +70,27 @@ export default config
 
 ```
 
+Import it explicitly in your document:
+
+```mdx
+import { Tonnage } from "tonnage"
+import config from "./examples/tonnage.config.ts"
+
+<Tonnage config={config} />
+```
+
+Importing configuration from another folder does not change path resolution.
+Set `packageJson` to
+select a manifest, `exports.include` or `exports.exclude` to select subpaths,
+and `exports: false` to report only recipes. Use `heading` to customize the report
+heading and `target` to set esbuild's JavaScript target. Use `external` for
+additional imports intentionally supplied by consumers; peer dependencies are
+already external.
+
 Each recipe points to a reviewable entry file such as
 [examples/recipes/react-app.ts](./examples/recipes/react-app.ts). Use named
-imports in these files to represent the runtime surface a real application uses;
-unused package exports are tree-shaken.
+imports to represent the runtime surface a real application uses; unused package
+exports are tree-shaken. Keep server and client recipes separate.
 
 ```ts
 // @exhibit-region start recipe
@@ -52,117 +100,46 @@ export { useO } from "my-package/react"
 
 ```
 
-The default generated-section marker is `default`; the example uses `my-package`.
-The opening and closing comments use the forms
-`tonnage:my-package:start` and `tonnage:my-package:end`.
-
-## Run
-
-Run `tonnage write` during development to update the README. Run
-`tonnage check` in CI to recompute the same report without writing and exit
-nonzero when the README is stale. Run `tonnage --help` to see both commands and
-their optional config-path arguments.
-
-Pass a config path with `tonnage check path/to/tonnage.config.ts` or
-`tonnage write path/to/tonnage.config.ts`. Otherwise, Tonnage looks in the current
-directory for `tonnage.config.ts`, then `tonnage.config.mjs`, then
-`tonnage.config.js`. Config modules may use top-level `await`. Missing configs
-are errors. Use `--` before a config path that starts with a dash.
-
-Unknown options are ignored with warnings on stderr. Warnings do not change the
-exit status; `check` still exits nonzero when the report is stale.
-
-By default the tool reads `package.json`, writes `README.md`, and measures every
-public export except `./package.json`. Paths are resolved relative to the config
-file. Use `exports.include` or `exports.exclude` to select subpaths, recipe entry
-files to describe realistic runtime boundaries, and `external` for non-peer
-imports that the package intentionally leaves to its consumers.
-
-### Shell completion
-
-With `tonnage` available on your shell's `PATH`, install completion for your shell:
-
-```sh
-tonnage completion install bash
-tonnage completion install zsh
-tonnage completion install fish
-tonnage completion install nushell
-tonnage completion install carapace
-```
-
-Choose the integration you use. Completion suggests commands, help options, and
-config paths without loading your config or measuring bundles. Installation
-checks the shell's prerequisites and writes to its completion directory without
-editing shell profiles. It reports any setup needed for your shell. If Nushell
-already uses Carapace, install only the Carapace integration.
-
-Run `tonnage completion bash` (or another target above) to print the integration
-file without installing it. The `completion` command and comline's internal
-completion protocol commands are reserved for shell integration.
+The public API consists of `Tonnage`, `defineConfig`, and the `TonnageProps`,
+`TonnageConfig`, `TonnageExports`, `TonnageRecipe`, and `BundlePlatform` types.
 
 ## Report layout
 
-Generated reports adapt to the measurements they contain. An exports-only or
-recipes-only report puts its table directly below the configured report heading
-and describes only that type of measurement. A report with both types labels the
-tables `Package exports` and `Usage examples` so readers can distinguish complete
-runtime export surfaces from tree-shaken recipe bundles.
+Public-module rows retain the complete runtime export surface. Recipe rows
+bundle their entry files and tree-shake unused exports. Exports-only and
+recipes-only reports put their table directly below the report heading; a report
+with both labels its tables `Package exports` and `Usage examples`.
 
-Every layout states the exact measurement semantics: minified and level-9 gzip
-JavaScript bytes, with declarations, source maps, CSS, and other assets excluded.
-Peer dependencies remain external, and shared modules are counted once in each
-bundle.
-
-Reports use Galley's native table elements, with right-aligned byte columns and
-literal escaping for import names, entry paths, and recipe labels.
-
-For programmatic use, await both measurement and Markdown rendering:
-
-```ts
-import {
-	createTonnageReport,
-	defineConfig,
-	renderTonnageMarkdown,
-} from "tonnage"
-
-const config = defineConfig({ platform: "node" })
-const report = await createTonnageReport(config, process.cwd())
-const markdown = await renderTonnageMarkdown(report, config)
-```
+Sizes count minified JavaScript and level-9 gzip bytes. Declarations, source
+maps, CSS, and other assets are excluded. Peer dependencies stay external, and
+shared modules are counted once per bundle. Reports use Galley's native table
+elements, with right-aligned byte columns and literal escaping for import names,
+entry paths, and recipe labels.
 
 ## Package resolution and platforms
 
-Tonnage resolves the package's own public import name from the manifest selected
-by `packageJson`; a workspace package does not need to install or declare itself
-as a dependency. Root and subpath imports still go through esbuild's package
-resolver, so the manifest's `exports` restrictions and conditions apply. Runtime
-dependencies resolve from the measured package, while its peer dependencies stay
-external.
-
-The default `platform` is `neutral`. For packages without `exports`, Tonnage
-configures neutral resolution to try the `module` field and then `main`, so
-main-only packages and dependencies are actionable by default. With conditional
-`exports`, neutral does not enable the `browser` or `node` condition, so exports
-commonly fall through to their `default` target. Set `platform` to `browser` or
-`node` when that runtime is what you want to measure; those choices retain
-esbuild's native export conditions and main-field behavior. A recipe's
-`platform` overrides the report-wide setting for that recipe.
+Tonnage resolves the package's own public import name from the selected manifest;
+a workspace package does not need to install itself as a dependency. Root and
+subpath imports go through esbuild's package resolver, so export restrictions
+and conditions apply. Runtime dependencies resolve from the measured package.
 
-## MDX documents
+The default `platform` is `neutral`. For packages without `exports`, neutral
+resolution tries `module` and then `main`. With conditional `exports`, neutral
+does not enable the `browser` or `node` condition, so exports commonly fall
+through to `default`. Set `platform` to `browser` or `node` for those runtimes;
+a recipe's `platform` overrides the report-wide setting.
 
-Use [galley.md](https://www.npmjs.com/package/galley.md) to compose a README from source examples and reports:
+## Migrating from the standalone workflow
 
-```mdx
-import { Tonnage } from "tonnage/galley"
-import config from "./tonnage.config.ts"
-import Example from "./examples/recipes/react-app.ts" with { type: "code", lang: "ts" }
-
-<Example />
-
-<Tonnage config={config} />
-```
+Move your maintained README content to `README.mdx` and replace generated-section
+markers with `<Tonnage config={config} />`. Remove `marker` and `readme` from the
+configuration. Import `Tonnage` from `tonnage` instead of `tonnage/galley`, and
+replace `tonnage write` / `tonnage check` scripts with `galley write` /
+`galley check`. Galley generates the entire README from its MDX source.
 
-The component resolves paths relative to the containing document. Pass `directory` to measure another package. It produces the same tables as the CLI without writing a README or requiring generated-section markers. Tonnage includes Galley as a runtime dependency; add `galley.md` directly to your project's development dependencies to run `galley write` and `galley check` when authoring documents.
+The tonnage executable, shell completion, standalone measurement/report APIs,
+and Markdown section-editing helpers have been removed. Reusable configurations
+can continue to use `defineConfig`; render reports through the component.
 
 ## Bundle size
 
@@ -170,9 +147,8 @@ Package export sizes include complete runtime export surfaces.
 
 Sizes are exact minified and level-9 gzip JavaScript byte counts. Declarations, source maps, CSS, and other assets are excluded. Peer dependencies stay external, and shared modules are counted once per bundle.
 
-| Import           | Minified JS |   Gzip JS |
-| ---------------- | ----------: | --------: |
-| `tonnage`        |   491,915 B | 153,965 B |
-| `tonnage/galley` |   484,581 B | 151,561 B |
+| Import    | Minified JS |  Gzip JS |
+| --------- | ----------: | -------: |
+| `tonnage` |    49,281 B | 17,561 B |
 
 Report maintained with [tonnage](https://github.com/jeremybanka/tonnage).

package/README.mdx

@@ -1,143 +1,122 @@
-import { Tonnage } from "tonnage/galley"
+import { Tonnage } from "tonnage"
 import Configuration from "./examples/tonnage.config.ts" with { type: "code", lang: "ts" }
 import Recipe from "./examples/recipes/react-app.ts" with { type: "code", lang: "ts" }
 
 # tonnage
 
-Keep exact bundle size tables in a package README and fail CI when the checked-in
-numbers drift.
+Bundle size reports for [Galley](https://www.npmjs.com/package/galley.md) documents.
 
-The tool bundles real public package imports with esbuild, minifies the result,
-and reports JavaScript bytes before and after level-9 gzip. Public-module rows
-retain every runtime export; recipe entry files can select named exports and
-tree-shake the rest. Declarations, source maps, CSS, and other assets are not
-counted. Peer dependencies stay external, and shared modules are counted once
-per bundle.
+Tonnage bundles real public package imports with esbuild, minifies the result,
+and reports JavaScript bytes before and after level-9 gzip. Embed its component
+in a README source document, then use Galley to generate Markdown and detect
+stale reports in CI.
 
-## Configure
-
-Add the generated-section comments to the target README, then create a config
-beside the package manifest. The complete configuration exhibit is in
-[examples/tonnage.config.ts](./examples/tonnage.config.ts).
-<Configuration />
+## Install
 
-Each recipe points to a reviewable entry file such as
-[examples/recipes/react-app.ts](./examples/recipes/react-app.ts). Use named
-imports in these files to represent the runtime surface a real application uses;
-unused package exports are tree-shaken.
+Install tonnage and its required Galley peer:
 
-<Recipe />
+```sh
+pnpm add -D tonnage 'galley.md@^0.1.1'
+```
 
-The default generated-section marker is `default`; the example uses `my-package`.
-The opening and closing comments use the forms
-`tonnage:my-package:start` and `tonnage:my-package:end`.
+## Use
 
-## Run
+Create `README.mdx` beside your package manifest:
 
-Run `tonnage write` during development to update the README. Run
-`tonnage check` in CI to recompute the same report without writing and exit
-nonzero when the README is stale. Run `tonnage --help` to see both commands and
-their optional config-path arguments.
+```mdx
+import { Tonnage } from "tonnage"
 
-Pass a config path with `tonnage check path/to/tonnage.config.ts` or
-`tonnage write path/to/tonnage.config.ts`. Otherwise, Tonnage looks in the current
-directory for `tonnage.config.ts`, then `tonnage.config.mjs`, then
-`tonnage.config.js`. Config modules may use top-level `await`. Missing configs
-are errors. Use `--` before a config path that starts with a dash.
+# My package
 
-Unknown options are ignored with warnings on stderr. Warnings do not change the
-exit status; `check` still exits nonzero when the report is stale.
+<Tonnage config={{ platform: "node" }} />
+```
 
-By default the tool reads `package.json`, writes `README.md`, and measures every
-public export except `./package.json`. Paths are resolved relative to the config
-file. Use `exports.include` or `exports.exclude` to select subpaths, recipe entry
-files to describe realistic runtime boundaries, and `external` for non-peer
-imports that the package intentionally leaves to its consumers.
+Run `galley write` to generate `README.md`. Run `galley check` in CI to evaluate
+the document again and exit nonzero if its output is missing or stale. Keep the
+MDX source and generated Markdown in version control.
 
-### Shell completion
+The component defaults to measuring every public export except `./package.json`.
+Paths resolve relative to the containing document. To measure another package,
+pass `directory`, such as `<Tonnage directory="../my-package" />`; relative
+values resolve from the document's directory. The `packageJson` path resolves
+from that measurement directory; recipe entry paths resolve from the selected
+manifest's directory.
 
-With `tonnage` available on your shell's `PATH`, install completion for your shell:
+Galley owns document evaluation and output files. See its
+[user guide](https://github.com/jeremybanka/galley#readme) for document composition
+and command options.
 
-```sh
-tonnage completion install bash
-tonnage completion install zsh
-tonnage completion install fish
-tonnage completion install nushell
-tonnage completion install carapace
-```
+## Configure
 
-Choose the integration you use. Completion suggests commands, help options, and
-config paths without loading your config or measuring bundles. Installation
-checks the shell's prerequisites and writes to its completion directory without
-editing shell profiles. It reports any setup needed for your shell. If Nushell
-already uses Carapace, install only the Carapace integration.
+Pass configuration inline or import a reusable configuration using `defineConfig`.
+The complete configuration exhibit is in
+[examples/tonnage.config.ts](./examples/tonnage.config.ts).
 
-Run `tonnage completion bash` (or another target above) to print the integration
-file without installing it. The `completion` command and comline's internal
-completion protocol commands are reserved for shell integration.
+<Configuration />
 
-## Report layout
+Import it explicitly in your document:
 
-Generated reports adapt to the measurements they contain. An exports-only or
-recipes-only report puts its table directly below the configured report heading
-and describes only that type of measurement. A report with both types labels the
-tables `Package exports` and `Usage examples` so readers can distinguish complete
-runtime export surfaces from tree-shaken recipe bundles.
+```mdx
+import { Tonnage } from "tonnage"
+import config from "./examples/tonnage.config.ts"
 
-Every layout states the exact measurement semantics: minified and level-9 gzip
-JavaScript bytes, with declarations, source maps, CSS, and other assets excluded.
-Peer dependencies remain external, and shared modules are counted once in each
-bundle.
+<Tonnage config={config} />
+```
 
-Reports use Galley's native table elements, with right-aligned byte columns and
-literal escaping for import names, entry paths, and recipe labels.
+Importing configuration from another folder does not change path resolution.
+Set `packageJson` to
+select a manifest, `exports.include` or `exports.exclude` to select subpaths,
+and `exports: false` to report only recipes. Use `heading` to customize the report
+heading and `target` to set esbuild's JavaScript target. Use `external` for
+additional imports intentionally supplied by consumers; peer dependencies are
+already external.
 
-For programmatic use, await both measurement and Markdown rendering:
+Each recipe points to a reviewable entry file such as
+[examples/recipes/react-app.ts](./examples/recipes/react-app.ts). Use named
+imports to represent the runtime surface a real application uses; unused package
+exports are tree-shaken. Keep server and client recipes separate.
 
-```ts
-import {
-	createTonnageReport,
-	defineConfig,
-	renderTonnageMarkdown,
-} from "tonnage"
+<Recipe />
 
-const config = defineConfig({ platform: "node" })
-const report = await createTonnageReport(config, process.cwd())
-const markdown = await renderTonnageMarkdown(report, config)
-```
+The public API consists of `Tonnage`, `defineConfig`, and the `TonnageProps`,
+`TonnageConfig`, `TonnageExports`, `TonnageRecipe`, and `BundlePlatform` types.
 
-## Package resolution and platforms
+## Report layout
 
-Tonnage resolves the package's own public import name from the manifest selected
-by `packageJson`; a workspace package does not need to install or declare itself
-as a dependency. Root and subpath imports still go through esbuild's package
-resolver, so the manifest's `exports` restrictions and conditions apply. Runtime
-dependencies resolve from the measured package, while its peer dependencies stay
-external.
+Public-module rows retain the complete runtime export surface. Recipe rows
+bundle their entry files and tree-shake unused exports. Exports-only and
+recipes-only reports put their table directly below the report heading; a report
+with both labels its tables `Package exports` and `Usage examples`.
 
-The default `platform` is `neutral`. For packages without `exports`, Tonnage
-configures neutral resolution to try the `module` field and then `main`, so
-main-only packages and dependencies are actionable by default. With conditional
-`exports`, neutral does not enable the `browser` or `node` condition, so exports
-commonly fall through to their `default` target. Set `platform` to `browser` or
-`node` when that runtime is what you want to measure; those choices retain
-esbuild's native export conditions and main-field behavior. A recipe's
-`platform` overrides the report-wide setting for that recipe.
+Sizes count minified JavaScript and level-9 gzip bytes. Declarations, source
+maps, CSS, and other assets are excluded. Peer dependencies stay external, and
+shared modules are counted once per bundle. Reports use Galley's native table
+elements, with right-aligned byte columns and literal escaping for import names,
+entry paths, and recipe labels.
 
-## MDX documents
+## Package resolution and platforms
 
-Use [galley.md](https://www.npmjs.com/package/galley.md) to compose a README from source examples and reports:
+Tonnage resolves the package's own public import name from the selected manifest;
+a workspace package does not need to install itself as a dependency. Root and
+subpath imports go through esbuild's package resolver, so export restrictions
+and conditions apply. Runtime dependencies resolve from the measured package.
 
-```mdx
-import { Tonnage } from "tonnage/galley"
-import config from "./tonnage.config.ts"
-import Example from "./examples/recipes/react-app.ts" with { type: "code", lang: "ts" }
+The default `platform` is `neutral`. For packages without `exports`, neutral
+resolution tries `module` and then `main`. With conditional `exports`, neutral
+does not enable the `browser` or `node` condition, so exports commonly fall
+through to `default`. Set `platform` to `browser` or `node` for those runtimes;
+a recipe's `platform` overrides the report-wide setting.
 
-<Example />
+## Migrating from the standalone workflow
 
-<Tonnage config={config} />
-```
+Move your maintained README content to `README.mdx` and replace generated-section
+markers with `<Tonnage config={config} />`. Remove `marker` and `readme` from the
+configuration. Import `Tonnage` from `tonnage` instead of `tonnage/galley`, and
+replace `tonnage write` / `tonnage check` scripts with `galley write` /
+`galley check`. Galley generates the entire README from its MDX source.
 
-The component resolves paths relative to the containing document. Pass `directory` to measure another package. It produces the same tables as the CLI without writing a README or requiring generated-section markers. Tonnage includes Galley as a runtime dependency; add `galley.md` directly to your project's development dependencies to run `galley write` and `galley check` when authoring documents.
+The tonnage executable, shell completion, standalone measurement/report APIs,
+and Markdown section-editing helpers have been removed. Reusable configurations
+can continue to use `defineConfig`; render reports through the component.
 
-<Tonnage config={{ platform: "node", exports: { include: [".", "./galley"] } }} />
+<Tonnage config={{ platform: "node", exports: { include: ["."] } }} />

package/dist/index.d.mts

@@ -1,36 +1,37 @@
-import { a as TonnageMode, c as TonnageReport, i as TonnageExports, l as TonnageRow, n as BundlePlatform, o as TonnageRecipe, r as TonnageConfig, s as TonnageRecipeRow, t as BundleMeasurement, u as TonnageRunResult } from "./types-Ddtp95Z3.mjs";
-import "esbuild";
-//#region src/define-config.d.ts
-export declare function defineConfig(config: TonnageConfig): TonnageConfig;
-//#endregion
-//#region src/measure.d.ts
-type MeasureImportsOptions = {
-  external?: readonly string[] | undefined;
-  platform?: BundlePlatform | undefined;
-  resolveDirectory: string;
-  target?: string | undefined;
+import { DocumentContext, Element } from "galley.md";
+//#region src/types.d.ts
+type BundlePlatform = `browser` | `neutral` | `node`;
+type TonnageExports = {
+  exclude?: readonly string[];
+  include?: readonly string[];
 };
-type MeasureEntryOptions = MeasureImportsOptions;
-export declare function measureEntry(entry: string, options: MeasureEntryOptions): Promise<BundleMeasurement>;
-export declare function measureImports(imports: readonly string[], options: MeasureImportsOptions): Promise<BundleMeasurement>;
-//#endregion
-//#region src/readme.d.ts
-export declare function tonnageMarkers(marker?: string): {
-  end: string;
-  start: string;
+type TonnageRecipe = {
+  entry: string;
+  external?: readonly string[];
+  name: string;
+  platform?: BundlePlatform;
+};
+type TonnageConfig = {
+  exports?: boolean | TonnageExports;
+  external?: readonly string[];
+  heading?: string;
+  packageJson?: string;
+  platform?: BundlePlatform;
+  recipes?: readonly TonnageRecipe[];
+  target?: string;
 };
-export declare function updateGeneratedSection(readme: string, markdown: string, marker?: string): string;
 //#endregion
-//#region src/report.d.ts
-export declare function createTonnageReport(config: TonnageConfig, configDirectory: string): Promise<TonnageReport>;
-/** Serialize a report with the same Galley elements used by the document component. */
-export declare function renderTonnageMarkdown(report: TonnageReport, config?: TonnageConfig): Promise<string>;
+//#region src/define-config.d.ts
+export declare function defineConfig(config: TonnageConfig): TonnageConfig;
 //#endregion
-//#region src/run.d.ts
-export declare function runTonnage(config: TonnageConfig, options: {
-  configDirectory?: string;
-  mode: TonnageMode;
-}): Promise<TonnageRunResult>;
+//#region src/galley.d.ts
+type TonnageProps = {
+  config?: TonnageConfig;
+  /** Override the document directory when measuring a different package. */
+  directory?: string;
+};
+/** Measure bundles and include the report in a galley.md document. */
+export declare function Tonnage({ config, directory }: TonnageProps, context: DocumentContext): Promise<Element[]>;
 //#endregion
-export type { BundleMeasurement, BundlePlatform, MeasureEntryOptions, MeasureImportsOptions, TonnageConfig, TonnageExports, TonnageMode, TonnageRecipe, TonnageRecipeRow, TonnageReport, TonnageRow, TonnageRunResult };
+export type { BundlePlatform, TonnageConfig, TonnageExports, TonnageProps, TonnageRecipe };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/define-config.ts","../src/measure.ts","../src/readme.ts","../src/report.ts","../src/run.ts"],"mappings":";;;wBAEgB,aAAa,QAAQ,gBAAgB;;;KCKzC;EACX;EACA,WAAW;EACX;EACA;;KAGW,sBAAsB;wBAMZ,aACrB,eACA,SAAS,sBACP,QAAQ;wBAcW,eACrB,4BACA,SAAS,wBACP,QAAQ;;;wBCxCK,eAAe;EAC9B;EACA;;wBASe,uBACf,gBACA,kBACA;;;wBCUqB,oBACrB,QAAQ,eACR,0BACE,QAAQ;;wBAgEW,sBACrB,QAAQ,eACR,SAAQ,gBACN;;;wBCvFmB,WACrB,QAAQ,eACR;EACC;EACA,MAAM;IAEL,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/define-config.ts","../src/galley.ts"],"mappings":";;KAAY;KAEA;EACX;EACA;;KAGW;EACX;EACA;EACA;EACA,WAAW;;KAGA;EACX,oBAAoB;EACpB;EACA;EACA;EACA,WAAW;EACX,mBAAmB;EACnB;;;;wBCnBe,aAAa,QAAQ,gBAAgB;;;KCMzC;EACX,SAAS;;EAET;;;wBAIqB,UACnB,QAAa,aAAa,cAC5B,SAAS,kBACP,QAAQ"}