@packall/core 0.3.2 → 0.4.0

package/dist/layout.d.ts

@@ -1,7 +1,8 @@
 /**
  * The on-disk shape of a bundle.
  *
- * Everything is laid out exactly the way a registry serves it:
+ * Under every layout but `flat`, everything is laid out exactly the way a
+ * registry serves it:
  *
  *     lodash/-/lodash-4.17.21.tgz
  *     @babel/core/-/core-7.24.0.tgz
@@ -13,7 +14,10 @@
  * The one shape worth noticing before editing anything here: a scoped
  * package's file name drops the scope, so `@babel/core` becomes
  * `core-7.24.0.tgz` under an `@babel/core/-/` directory.
+ *
+ * `flat` layout is the exception; `bundlePath` is where the two part company.
  */
+import { Layout } from "./enums/layout.js";
 /** Splits `@scope/name` into its parts. `scope` is undefined when unscoped. */
 export declare const splitName: (name: string) => {
     readonly scope: string | undefined;
@@ -32,7 +36,7 @@ export declare const MANIFEST_FILE = "bundle-manifest.json";
 /** File name of the short import guide that ships inside every bundle. */
 export declare const README_FILE = "IMPORT.md";
 /**
- * Name of the archive produced for one root spec in `per-spec` layout.
+ * A flat, collision-free file name for one `name@version`.
  *
  * It is the spec, with the one character a file name cannot hold taken out:
  * `@types/react@19.2.18` becomes `@types-react@19.2.18.tgz`. So the name of the
@@ -62,26 +66,58 @@ export declare const README_FILE = "IMPORT.md";
  * has to cross-reference against a manifest.
  *
  * It does not make every collision impossible — `@a/b-c` and `@a-b/c` still
- * meet — so `assertDistinctOutputs` still runs. That pair is pathological; the
- * scoped-against-unscoped one is `@babel/core` beside `babel-core`, which is a
- * real migration somebody could be bundling.
+ * meet — so the run still checks before downloading anything. That pair is
+ * pathological; the scoped-against-unscoped one is `@babel/core` beside
+ * `babel-core`, which is a real migration somebody could be bundling.
  *
  * The leading `@` is safe here in a way it is not inside the archive: tar's
  * splice convention applies to the *file list* it is given, which is what
- * `archive.ts` guards with `./`. This is the output path, not an entry.
+ * `archive.ts` guards with `./`. These are output paths, not entries.
+ */
+export declare const flatName: (name: string, version: string) => string;
+/**
+ * Name of the archive produced for one root spec in `per-spec` layout.
+ *
+ * The same rule as {@link flatName}, which is where the reasoning lives — a
+ * per-spec archive and a `flat` package tarball are both "one file in a
+ * directory, named for what is in it", and there is no reason for a directory
+ * of bundles and a directory of packages to be read differently.
+ */
+export declare const perSpecArchiveName: typeof flatName;
+/**
+ * The path of one package tarball within a bundle. The one place the two
+ * shapes are chosen between, so a manifest and the tree it describes cannot
+ * drift apart.
+ *
+ * `flat` keeps a file name and no directories, and uses {@link flatName}
+ * rather than the registry file name: with the directories gone that name is
+ * all there is to tell two packages apart, and the registry one drops the
+ * scope, which would put `@types/node` and `node` on the same file. The name
+ * is free to differ — `npm publish <tarball>` reads a package's name and
+ * version from the `package.json` inside it, not from what the file is
+ * called.
  */
-export declare const perSpecArchiveName: (name: string, version: string) => string;
+export declare const bundlePath: (layout: Layout, name: string, version: string) => string;
 /** Name of the archive produced in `single` layout. */
 export declare const singleArchiveName: (base?: string) => string;
+/** Shared by both guides. */
+type GuideOptions = {
+    readonly packageCount: number;
+    readonly createdAt: string;
+    readonly toolVersion: string;
+    readonly layout: Layout;
+};
 /**
  * The import guide written into each bundle.
  *
  * Kept short and copy-pasteable on purpose: whoever opens this is mid-task on a
  * restricted network and does not want prose.
+ *
+ * Layout-aware, because the instructions genuinely differ — a registry-layout
+ * tree uploads into Artifactory as it stands and a flat directory does not, and
+ * a guide that said otherwise would be discovered to be wrong by somebody who
+ * can no longer look anything up.
  */
-export declare const importGuide: (options: {
-    readonly packageCount: number;
-    readonly createdAt: string;
-    readonly toolVersion: string;
-}) => string;
+export declare const importGuide: (options: GuideOptions) => string;
+export {};
 //# sourceMappingURL=layout.d.ts.map

package/dist/layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,SAAS,SACf,MAAM,KACV;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAK7D,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,eAAe,SAAU,MAAM,WAAW,MAAM,KAAG,MAG/D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,WAAW,MAAM,KAAG,MACd,CAAC;AAE/C,gEAAgE;AAChE,eAAO,MAAM,aAAa,yBAAyB,CAAC;AAEpD,0EAA0E;AAC1E,eAAO,MAAM,WAAW,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,kBAAkB,SAAU,MAAM,WAAW,MAAM,KAAG,MAIlE,CAAC;AAEF,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,qBAAsB,MAAuB,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,YAAa;IACpC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B,KAAG,MA+BH,CAAC"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../src/layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,+EAA+E;AAC/E,eAAO,MAAM,SAAS,SACf,MAAM,KACV;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAK7D,CAAC;AAEF,oDAAoD;AACpD,eAAO,MAAM,eAAe,SAAU,MAAM,WAAW,MAAM,KAAG,MAG/D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAU,MAAM,WAAW,MAAM,KAAG,MACd,CAAC;AAE/C,gEAAgE;AAChE,eAAO,MAAM,aAAa,yBAAyB,CAAC;AAEpD,0EAA0E;AAC1E,eAAO,MAAM,WAAW,cAAc,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,QAAQ,SAAU,MAAM,WAAW,MAAM,KAAG,MAIxD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,iBAAW,CAAC;AAE3C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,WAAY,MAAM,QAAQ,MAAM,WAAW,MAAM,KAAG,MACG,CAAC;AAE/E,uDAAuD;AACvD,eAAO,MAAM,iBAAiB,qBAAsB,MAAuB,CAAC;AAE5E,6BAA6B;AAC7B,KAAK,YAAY,GAAG;IACnB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,YAAa,YAAY,KAAG,MACqB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@packall/core",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Registry-agnostic engine for bundling npm packages and their full dependency closure for offline import.",
   "homepage": "https://packall.vercel.app",
   "bugs": {

package/src/bundle.ts

@@ -32,6 +32,7 @@ import { Phase } from "./enums/phase.js";
 import type { BundlerError } from "./errors.js";
 import { OutputError } from "./errors.js";
 import {
+	flatName,
 	importGuide,
 	MANIFEST_FILE,
 	packagePath,
@@ -57,7 +58,7 @@ export type BundleArtifact = {
 	readonly path: string;
 	readonly bytes: number;
 	readonly packageCount: number;
-	/** Which spec this artifact covers. Absent for `single` and `dir`. */
+	/** Which spec this artifact covers. Only `per-spec` sets it. */
 	readonly spec?: string | undefined;
 	readonly version?: string | undefined;
 };
@@ -99,11 +100,12 @@ export type PlanSummary = {
 /**
  * The files a run will write, known before anything is downloaded.
  *
- * `dir` layout is the odd one: it merges a package tree into `outDir`, and
- * package paths are `name/-/name-version.tgz` — the same package at the same
- * version is the same bytes, so an overlap there is idempotent rather than
- * destructive. Only the two summary files are genuinely replaced, and those are
- * the ones worth guarding.
+ * `dir` and `flat` are the odd ones: they merge a package tree into `outDir`
+ * rather than writing an archive. Either way a package's path is derived from
+ * its name and version, so the same package at the same version is the same
+ * bytes at the same path — an overlap is idempotent rather than destructive.
+ * Only the two summary files are genuinely replaced, and those are the ones
+ * worth guarding.
  */
 export type PlannedOutput = {
 	readonly file: string;
@@ -294,7 +296,9 @@ export const plannedOutputs = (
 	resolution: Resolution,
 	options: BundleContext,
 ): ReadonlyArray<PlannedOutput> => {
-	if (options.layout === Layout.Dir) return [{ file: MANIFEST_FILE }, { file: README_FILE }];
+	if (options.layout === Layout.Dir || options.layout === Layout.Flat) {
+		return [{ file: MANIFEST_FILE }, { file: README_FILE }];
+	}
 	if (options.layout === Layout.Single) {
 		return [{ file: singleArchiveName(options.archiveName ?? "bundle") }];
 	}
@@ -371,6 +375,8 @@ const emit = (
 			return emitDirectory(input);
 		case Layout.PerSpec:
 			return emitPerSpec(input, staging);
+		case Layout.Flat:
+			return emitFlat(input, staging);
 	}
 };
 
@@ -460,6 +466,89 @@ const emitDirectory = (
 		];
 	});
 
+/**
+ * The flat directory: every tarball side by side, no archive, no nesting.
+ *
+ * The tarballs are the untouched registry ones — only their names are ours,
+ * and `bundlePath` says why.
+ */
+const emitFlat = (
+	input: EmitInput,
+	staging: string,
+): Effect.Effect<
+	ReadonlyArray<BundleArtifact>,
+	BundlerError | PlatformError,
+	FileSystem.FileSystem | Path.Path
+> =>
+	Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+
+		// Staged and then copied rather than written straight into `outDir`, so a
+		// failure partway through leaves the output directory as it was.
+		const flatDir = path.join(staging, "flat");
+		yield* fs.makeDirectory(flatDir, { recursive: true });
+
+		for (const pkg of input.resolution.packages) {
+			const parts = packagePath(pkg.name, pkg.version).split("/");
+			yield* linkOrCopy(
+				path.join(input.packagesDir, ...parts),
+				path.join(flatDir, flatName(pkg.name, pkg.version)),
+			);
+		}
+
+		yield* writeBundleMetadata({
+			dir: flatDir,
+			resolution: input.resolution,
+			included: input.resolution.packages,
+			options: input.options,
+			registryInfo: input.registryInfo,
+			sizes: input.report.sizes,
+		});
+
+		yield* fs.copy(flatDir, input.options.outDir, { overwrite: true }).pipe(
+			Effect.mapError(
+				(cause) =>
+					new OutputError(input.options.outDir, "could not write output tree", {
+						cause,
+					}),
+			),
+		);
+
+		// One artifact per file, not one for the directory.
+		//
+		// `dir` reports its tree as a single artifact because the tree is the
+		// unit: the paths are what make it importable, so half of it is worth
+		// nothing. Flat has no paths to preserve and every file stands on its
+		// own — `npm publish` takes them one at a time, in any order. Reporting
+		// one artifact there contradicted the directory it had just written, and
+		// the run said "1 artifact" over 56 files.
+		//
+		// The manifest and the import guide are counted too: under this layout
+		// they are loose files the run produced, and a count that omitted them
+		// would not match what `ls` shows.
+		const tarballs: ReadonlyArray<BundleArtifact> = input.resolution.packages.map((pkg) => ({
+			kind: ArtifactKind.Archive,
+			path: path.join(input.options.outDir, flatName(pkg.name, pkg.version)),
+			bytes: input.report.sizes.get(`${pkg.name}@${pkg.version}`) ?? 0,
+			packageCount: 1,
+		}));
+
+		const summaries = yield* Effect.forEach([MANIFEST_FILE, README_FILE], (file) =>
+			Effect.gen(function* () {
+				const info = yield* fs.stat(path.join(flatDir, file));
+				return {
+					kind: ArtifactKind.File,
+					path: path.join(input.options.outDir, file),
+					bytes: Number(info.size),
+					packageCount: 0,
+				} satisfies BundleArtifact;
+			}),
+		);
+
+		return [...tarballs, ...summaries];
+	});
+
 /**
  * One tarball per resolved root *version*.
  *
@@ -597,6 +686,7 @@ const writeBundleMetadata = (input: {
 				packageCount: input.included.length,
 				createdAt: createdAt.toISOString(),
 				toolVersion: input.options.toolVersion,
+				layout: input.options.layout,
 			}),
 		);
 	});
@@ -611,6 +701,48 @@ const topLevelEntries = (
 		return entries.toSorted();
 	});
 
+/**
+ * `assertDistinctOutputs`, over package tarballs instead of archives.
+ *
+ * `flat` is the only layout with nothing but a file name to tell two packages
+ * apart — everywhere else a tarball keeps its unique `name/-/` directory. What
+ * is left to catch is the pathological pair, `@a/b-c` against `@a-b/c`; the
+ * plausible one is impossible by construction, which is what `flatName` buys.
+ */
+const assertDistinctFlatNames = (
+	resolution: Resolution,
+	options: BundleContext,
+): Effect.Effect<void, OutputError> =>
+	Effect.gen(function* () {
+		if (options.layout !== Layout.Flat) return;
+
+		const owners = new Map<string, Array<string>>();
+		for (const pkg of resolution.packages) {
+			const file = flatName(pkg.name, pkg.version);
+			const claimed = owners.get(file);
+
+			if (claimed === undefined) owners.set(file, [`${pkg.name}@${pkg.version}`]);
+			else claimed.push(`${pkg.name}@${pkg.version}`);
+		}
+
+		const collisions = [...owners].filter(([, packages]) => packages.length > 1);
+		if (collisions.length === 0) return;
+
+		const described = collisions
+			.map(([file, packages]) => `${packages.join(" and ")} would both be ${file}`)
+			.join("; ");
+
+		return yield* Effect.fail(
+			new OutputError(
+				options.outDir,
+				`two packages want the same file name — ${described}. \`flat\` layout has ` +
+					`only the file name to tell them apart, and the \`/\` in a scope becomes ` +
+					`a \`-\` to make one. Use --layout dir, which keeps each package in its ` +
+					`own directory.`,
+			),
+		);
+	});
+
 /**
  * Two different packages must not want the same file name.
  *
@@ -701,6 +833,7 @@ const prepareOutputDir = (
 		const outDir = options.outDir;
 
 		yield* assertDistinctOutputs(resolution, options);
+		yield* assertDistinctFlatNames(resolution, options);
 
 		if (!options.force) {
 			const clashes: Array<string> = [];

package/src/enums/artifact-kind.ts

@@ -4,6 +4,12 @@ import type { ValueOf } from "../types/value-of.js";
 export const ArtifactKind = {
 	Archive: "archive",
 	Directory: "directory",
+	/**
+	 * A loose file that is not an archive — the manifest and the import guide,
+	 * which `dir` and `flat` write beside the tarballs rather than sealing
+	 * inside one.
+	 */
+	File: "file",
 } as const;
 
 export type ArtifactKind = ValueOf<typeof ArtifactKind>;

package/src/enums/layout.ts

@@ -18,6 +18,12 @@ export const Layout = {
 	 * `jf rt upload` or rsync.
 	 */
 	Dir: "dir",
+	/**
+	 * Every tarball side by side in one directory — no archive, and no
+	 * `name/-/` nesting. For tooling that globs `*.tgz` out of one directory
+	 * rather than walking a registry tree.
+	 */
+	Flat: "flat",
 } as const;
 
 export type Layout = ValueOf<typeof Layout>;

package/src/layout.ts

@@ -1,7 +1,8 @@
 /**
  * The on-disk shape of a bundle.
  *
- * Everything is laid out exactly the way a registry serves it:
+ * Under every layout but `flat`, everything is laid out exactly the way a
+ * registry serves it:
  *
  *     lodash/-/lodash-4.17.21.tgz
  *     @babel/core/-/core-7.24.0.tgz
@@ -13,8 +14,12 @@
  * The one shape worth noticing before editing anything here: a scoped
  * package's file name drops the scope, so `@babel/core` becomes
  * `core-7.24.0.tgz` under an `@babel/core/-/` directory.
+ *
+ * `flat` layout is the exception; `bundlePath` is where the two part company.
  */
 
+import { Layout } from "./enums/layout.js";
+
 /** Splits `@scope/name` into its parts. `scope` is undefined when unscoped. */
 export const splitName = (
 	name: string,
@@ -46,7 +51,7 @@ export const MANIFEST_FILE = "bundle-manifest.json";
 export const README_FILE = "IMPORT.md";
 
 /**
- * Name of the archive produced for one root spec in `per-spec` layout.
+ * A flat, collision-free file name for one `name@version`.
  *
  * It is the spec, with the one character a file name cannot hold taken out:
  * `@types/react@19.2.18` becomes `@types-react@19.2.18.tgz`. So the name of the
@@ -76,34 +81,72 @@ export const README_FILE = "IMPORT.md";
  * has to cross-reference against a manifest.
  *
  * It does not make every collision impossible — `@a/b-c` and `@a-b/c` still
- * meet — so `assertDistinctOutputs` still runs. That pair is pathological; the
- * scoped-against-unscoped one is `@babel/core` beside `babel-core`, which is a
- * real migration somebody could be bundling.
+ * meet — so the run still checks before downloading anything. That pair is
+ * pathological; the scoped-against-unscoped one is `@babel/core` beside
+ * `babel-core`, which is a real migration somebody could be bundling.
  *
  * The leading `@` is safe here in a way it is not inside the archive: tar's
  * splice convention applies to the *file list* it is given, which is what
- * `archive.ts` guards with `./`. This is the output path, not an entry.
+ * `archive.ts` guards with `./`. These are output paths, not entries.
  */
-export const perSpecArchiveName = (name: string, version: string): string => {
+export const flatName = (name: string, version: string): string => {
 	const { scope, bare } = splitName(name);
 	const prefix = scope === undefined ? bare : `${scope}-${bare}`;
 	return `${prefix}@${version}.tgz`;
 };
 
+/**
+ * Name of the archive produced for one root spec in `per-spec` layout.
+ *
+ * The same rule as {@link flatName}, which is where the reasoning lives — a
+ * per-spec archive and a `flat` package tarball are both "one file in a
+ * directory, named for what is in it", and there is no reason for a directory
+ * of bundles and a directory of packages to be read differently.
+ */
+export const perSpecArchiveName = flatName;
+
+/**
+ * The path of one package tarball within a bundle. The one place the two
+ * shapes are chosen between, so a manifest and the tree it describes cannot
+ * drift apart.
+ *
+ * `flat` keeps a file name and no directories, and uses {@link flatName}
+ * rather than the registry file name: with the directories gone that name is
+ * all there is to tell two packages apart, and the registry one drops the
+ * scope, which would put `@types/node` and `node` on the same file. The name
+ * is free to differ — `npm publish <tarball>` reads a package's name and
+ * version from the `package.json` inside it, not from what the file is
+ * called.
+ */
+export const bundlePath = (layout: Layout, name: string, version: string): string =>
+	layout === Layout.Flat ? flatName(name, version) : packagePath(name, version);
+
 /** Name of the archive produced in `single` layout. */
 export const singleArchiveName = (base = "bundle"): string => `${base}.tgz`;
 
+/** Shared by both guides. */
+type GuideOptions = {
+	readonly packageCount: number;
+	readonly createdAt: string;
+	readonly toolVersion: string;
+	readonly layout: Layout;
+};
+
 /**
  * The import guide written into each bundle.
  *
  * Kept short and copy-pasteable on purpose: whoever opens this is mid-task on a
  * restricted network and does not want prose.
+ *
+ * Layout-aware, because the instructions genuinely differ — a registry-layout
+ * tree uploads into Artifactory as it stands and a flat directory does not, and
+ * a guide that said otherwise would be discovered to be wrong by somebody who
+ * can no longer look anything up.
  */
-export const importGuide = (options: {
-	readonly packageCount: number;
-	readonly createdAt: string;
-	readonly toolVersion: string;
-}): string =>
+export const importGuide = (options: GuideOptions): string =>
+	options.layout === Layout.Flat ? flatGuide(options) : treeGuide(options);
+
+const treeGuide = (options: GuideOptions): string =>
 	`# Importing this bundle
 
 ${options.packageCount} package tarball(s), laid out exactly as an npm registry serves them:
@@ -135,3 +178,31 @@ Publish each tarball individually:
 Every entry in ${MANIFEST_FILE} carries the integrity string the source registry
 advertised, and each tarball was checked against it at download time.
 `;
+
+const flatGuide = (options: GuideOptions): string =>
+	`# Importing this bundle
+
+${options.packageCount} package tarball(s), side by side in this one directory:
+
+    <name>@<version>.tgz
+    @<scope>-<name>@<version>.tgz
+
+Created ${options.createdAt} by packall ${options.toolVersion}.
+See ${MANIFEST_FILE} for the full list with checksums.
+
+## Publishing into a registry
+
+\`npm publish\` reads each package's name and version from the \`package.json\`
+inside its tarball, so neither the file names nor the order matter:
+
+    for f in *.tgz; do npm publish --registry <url> "$f"; done
+
+For a tree that uploads into Artifactory as it stands, use --layout dir instead.
+
+## Verifying before import
+
+    node -e "const m=require('./${MANIFEST_FILE}');console.log(m.packages.length+' packages')"
+
+Every entry in ${MANIFEST_FILE} carries the integrity string the source registry
+advertised, and each tarball was checked against it at download time.
+`;

package/src/manifest.ts

@@ -2,7 +2,7 @@
  * The manifest written into every bundle — the audit trail, answerable without
  * unpacking a single tarball. See `notes/requirements.md` § FR-10.
  */
-import { packagePath } from "./layout.js";
+import { bundlePath } from "./layout.js";
 import type { BundleOptions } from "./options.js";
 import { formatPlatformFilter } from "./platform.js";
 import type { Resolution, ResolvedPackage } from "./resolve.js";
@@ -82,7 +82,7 @@ export const buildManifest = (input: {
 		return {
 			name: pkg.name,
 			version: pkg.version,
-			path: packagePath(pkg.name, pkg.version),
+			path: bundlePath(input.options.layout, pkg.name, pkg.version),
 			tarball: pkg.manifest.dist.tarball,
 			integrity: pkg.manifest.dist.integrity,
 			shasum: pkg.manifest.dist.shasum,