@neta-art/cohub-cli 10.4.1 → 10.4.2

package/dist/board-kernel.js

@@ -6821,20 +6821,20 @@ const CAMERA_PROPERTIES = {
 			y: number$1().finite(),
 			width: number$1().finite().positive(),
 			height: number$1().finite().positive()
-		}).strict()])
+		}).strict()]).describe("Item id or world-space rect to fit with 48 px padding; holds until the next focus keyframe.")
 	},
 	zoom: {
 		kind: "number",
-		schema: number$1().finite().positive(),
+		schema: number$1().finite().positive().describe("Pixels per world unit; overrides the zoom computed by focus."),
 		multiplicative: true
 	},
 	center: {
 		kind: "vec2",
-		schema: BoardVec2Schema$1
+		schema: BoardVec2Schema$1.describe("World-space viewport center; overrides focus positioning using the resolved zoom.")
 	},
 	shake: {
 		kind: "number",
-		schema: number$1().finite().nonnegative()
+		schema: number$1().finite().nonnegative().describe("Shake amplitude in screen pixels, applied after focus, zoom and center.")
 	}
 };
 const ANIMATION_PROPERTIES = { time: {
@@ -7338,6 +7338,86 @@ function parseBoardDocument(input) {
 	} : result;
 }
 //#endregion
+//#region ../protocol/src/board.ts
+const BOARD_EXTENSION = ".board";
+const BOARD_MIME_TYPE = "application/json";
+object({
+	kind: literal("cohub.board.manifest"),
+	version: literal(1),
+	boardId: string().uuid(),
+	title: string().min(1).max(255)
+});
+const BOARD_READ_SECTIONS = ["items", "animations"];
+const rectSchema = object({
+	x: number$1().finite(),
+	y: number$1().finite(),
+	width: number$1().finite().positive(),
+	height: number$1().finite().positive()
+}).strict();
+object({
+	only: array(_enum(BOARD_READ_SECTIONS)).optional(),
+	rect: rectSchema.optional(),
+	within: BoardIdSchema$1.optional(),
+	items: array(string().min(1)).max(5e4).optional(),
+	animations: array(string().min(1)).max(1e4).optional(),
+	limit: number$1().int().min(1).max(5e4).optional(),
+	cursor: string().min(1).optional()
+}).strict().refine((read) => !(read.cursor && (read.rect || read.within)), {
+	path: ["cursor"],
+	message: "cursor pages by id, so it cannot be combined with rect or within"
+});
+object({
+	patch: BoardPatchSchema$1,
+	replace: boolean().default(false),
+	cascade: boolean().default(false),
+	dryRun: boolean().default(false),
+	baseVersion: number$1().int().nonnegative().optional(),
+	mutationId: string().min(1).max(160).optional(),
+	clientId: string().min(1).max(160).optional()
+}).strict();
+object({
+	path: string().min(1),
+	title: string().min(1).max(255).optional(),
+	document: BoardPatchSchema$1.optional(),
+	mutationId: string().max(160).optional()
+}).strict();
+object({
+	before: number$1().int().positive().optional(),
+	limit: number$1().int().min(1).max(500).default(200)
+}).strict();
+const commandId = string().min(1).max(160);
+discriminatedUnion("type", [
+	object({
+		commandId,
+		type: literal("play"),
+		animationId: string().min(1),
+		position: number$1().finite().nonnegative().optional(),
+		timeScale: number$1().finite().positive().max(4).optional(),
+		seed: string().min(1).max(160).optional()
+	}).strict(),
+	object({
+		commandId,
+		type: literal("pause")
+	}).strict(),
+	object({
+		commandId,
+		type: literal("resume")
+	}).strict(),
+	object({
+		commandId,
+		type: literal("seek"),
+		position: number$1().finite().nonnegative()
+	}).strict(),
+	object({
+		commandId,
+		type: literal("next")
+	}).strict(),
+	object({
+		commandId,
+		type: literal("stop")
+	}).strict()
+]);
+//#endregion
 //#region ../protocol/src/board-task.ts
 function artifactScore(artifact) {
 	const kind = {
@@ -7374,6 +7454,117 @@ function taskArtifactPreviewUrl(artifact) {
 	if (artifact?.type === "video" || artifact?.type === "audio") return artifact.previewUrl;
 }
 //#endregion
+//#region ../protocol/src/fs/mime.ts
+const MIME_BY_EXTENSION = {
+	".txt": "text/plain",
+	".md": "text/markdown",
+	".markdown": "text/markdown",
+	".json": "application/json",
+	".jsonl": "application/x-ndjson",
+	".csv": "text/csv",
+	[BOARD_EXTENSION]: BOARD_MIME_TYPE,
+	".js": "text/javascript",
+	".mjs": "text/javascript",
+	".cjs": "text/javascript",
+	".ts": "text/typescript",
+	".tsx": "text/tsx",
+	".jsx": "text/jsx",
+	".svelte": "text/x-svelte",
+	".css": "text/css",
+	".scss": "text/x-scss",
+	".html": "text/html",
+	".htm": "text/html",
+	".xml": "application/xml",
+	".yaml": "application/yaml",
+	".yml": "application/yaml",
+	".toml": "application/toml",
+	".ini": "text/plain",
+	".env": "text/plain",
+	".sh": "text/x-shellscript",
+	".bash": "text/x-shellscript",
+	".py": "text/x-python",
+	".go": "text/x-go",
+	".rs": "text/x-rust",
+	".java": "text/x-java-source",
+	".c": "text/x-c",
+	".h": "text/x-c",
+	".cpp": "text/x-c++src",
+	".hpp": "text/x-c++hdr",
+	".sql": "application/sql",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".bmp": "image/bmp",
+	".ico": "image/x-icon",
+	".mp4": "video/mp4",
+	".webm": "video/webm",
+	".mov": "video/quicktime",
+	".m4v": "video/x-m4v",
+	".ogv": "video/ogg",
+	".avi": "video/x-msvideo",
+	".mp3": "audio/mpeg",
+	".wav": "audio/wav",
+	".ogg": "audio/ogg",
+	".m4a": "audio/mp4",
+	".aac": "audio/aac",
+	".flac": "audio/flac",
+	".opus": "audio/ogg",
+	".glb": "model/gltf-binary",
+	".gltf": "model/gltf+json",
+	".stl": "model/stl",
+	".obj": "model/obj",
+	".3mf": "model/3mf",
+	".usdz": "model/vnd.usdz+zip",
+	".mtl": "text/plain",
+	".pdf": "application/pdf",
+	".wasm": "application/wasm",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".zip": "application/zip",
+	".gz": "application/gzip",
+	".tar": "application/x-tar",
+	".rar": "application/vnd.rar",
+	".7z": "application/x-7z-compressed",
+	".exe": "application/x-msdownload",
+	".dmg": "application/x-apple-diskimage",
+	".deb": "application/vnd.debian.binary-package",
+	".rpm": "application/x-rpm"
+};
+const MIME_BY_FILENAME = {
+	dockerfile: "text/x-dockerfile",
+	makefile: "text/x-makefile"
+};
+function mimeTypeForPath(path) {
+	const name = (path.split(/[\\/]/).pop() ?? "").toLowerCase();
+	const byName = Object.hasOwn(MIME_BY_FILENAME, name) ? MIME_BY_FILENAME[name] : void 0;
+	if (byName) return byName;
+	const dot = name.lastIndexOf(".");
+	const byExtension = dot > 0 ? MIME_BY_EXTENSION[name.slice(dot)] : void 0;
+	if (byExtension) return byExtension;
+	return name.startsWith(".") ? "text/plain" : null;
+}
+function normalizeMime$1(mimeType) {
+	if (!mimeType) return null;
+	return mimeType.split(";")[0]?.trim().toLowerCase() || null;
+}
+const MODEL_FORMAT_BY_MIME = {
+	"model/gltf-binary": "glb",
+	"model/gltf+json": "gltf",
+	"model/stl": "stl",
+	"model/obj": "obj"
+};
+function modelFormatForPath(path, mimeType) {
+	const format = (mime) => {
+		const key = normalizeMime$1(mime);
+		return key && Object.hasOwn(MODEL_FORMAT_BY_MIME, key) ? MODEL_FORMAT_BY_MIME[key] : void 0;
+	};
+	return format(mimeTypeForPath(path)) ?? format(mimeType) ?? null;
+}
+//#endregion
 //#region ../sdk/src/board/model/script-index.ts
 const scriptsByItems = /* @__PURE__ */ new WeakMap();
 function boardScriptItems(document) {
@@ -8470,7 +8661,6 @@ function boardSequence(document, chapters) {
 		const chapterIndex = String(index).padStart(String(chapters.length).length, "0");
 		for (const [id, track] of Object.entries(animation.tracks)) {
 			if (document.animations[track.target]) throw new Error(`Chapter ${chapter.animation} contains nested clocks; compose its leaf animations instead.`);
-			if (chapter.frame && track.target === "camera" && track.property === "focus") continue;
 			tracks[`chapter-${chapterIndex}-${ranks.get(id)}`] = {
 				...track,
 				keyframes: track.keyframes.map((keyframe) => ({
@@ -8501,7 +8691,7 @@ function boardSequence(document, chapters) {
 					}] : []
 				]
 			};
-			tracks[`camera-${index}`] = {
+			tracks[`chapter-${chapterIndex}--camera`] = {
 				target: "camera",
 				property: "focus",
 				composite: "replace",
@@ -9192,6 +9382,14 @@ function getMediaResourceTitle(value) {
 		return value.split("/").filter(Boolean).pop() || value;
 	}
 }
+function boardModelFormat(src, mimeType) {
+	const source = parseBoardMediaSource$1(src);
+	if (!source) return null;
+	return modelFormatForPath(source.kind === "url" ? source.value.split(/[?#]/, 1)[0] ?? "" : source.value, mimeType);
+}
+function isBoardModelItem(item) {
+	return item?.type === "file" && boardModelFormat(item.props.src, item.props.snapshot?.mimeType) !== null;
+}
 //#endregion
 //#region ../sdk/src/board/model/file-snapshot.ts
 /**
@@ -27372,6 +27570,14 @@ const PIXEL_GLYPHS = {
 		".###..",
 		".###.."
 	],
+	model: [
+		"..#...",
+		".###..",
+		"#####.",
+		"#####.",
+		".###..",
+		"..#..."
+	],
 	file: [
 		"####..",
 		"#..##.",
@@ -27422,6 +27628,9 @@ function drawLineGlyph(graphics, glyph, color) {
 			]) graphics.moveTo(x, 6 - height / 2).lineTo(x, 6 + height / 2);
 			graphics.stroke(line);
 			return;
+		case "model":
+			traceCube(graphics, 6, 6, 4.5).stroke(line);
+			return;
 		case "file":
 			graphics.poly([
 				2.5,
@@ -27459,6 +27668,25 @@ function drawLineGlyph(graphics, glyph, color) {
 			return;
 	}
 }
+function traceCube(graphics, cx, cy, radius) {
+	const dx = radius * .866;
+	const dy = radius / 2;
+	graphics.poly([
+		cx,
+		cy - radius,
+		cx + dx,
+		cy - dy,
+		cx + dx,
+		cy + dy,
+		cx,
+		cy + radius,
+		cx - dx,
+		cy + dy,
+		cx - dx,
+		cy - dy
+	]).moveTo(cx - dx, cy - dy).lineTo(cx, cy).lineTo(cx + dx, cy - dy).moveTo(cx, cy).lineTo(cx, cy + radius);
+	return graphics;
+}
 function drawCardGlyph(graphics, glyph, color, pixel) {
 	if (!pixel) {
 		drawLineGlyph(graphics, glyph, color);
@@ -27957,9 +28185,28 @@ function drawMediaPlayKey(graphics, cx, cy, radius, context, solid = false) {
 		alpha: .96
 	});
 }
+function drawModelKey(graphics, cx, cy, radius, context) {
+	if (context.style.corner === "pixel") {
+		const size = Math.round(radius * 1.6);
+		tracePixelRect(graphics, Math.round(cx - size / 2), Math.round(cy - size / 2), size, size, 2).fill({
+			color: MEDIA_SCRIM,
+			alpha: .62
+		});
+	} else graphics.circle(cx, cy, radius).fill({
+		color: MEDIA_SCRIM,
+		alpha: .45
+	});
+	traceCube(graphics, cx, cy, radius * .5).stroke({
+		color: MEDIA_INK,
+		width: Math.max(1, radius / 10),
+		alpha: .96,
+		join: "round",
+		cap: "round"
+	});
+}
 const GAP$1 = 12;
 const WAVE_HEIGHT = 16;
-const partsByContainer$12 = /* @__PURE__ */ new WeakMap();
+const partsByContainer$13 = /* @__PURE__ */ new WeakMap();
 function audioKeyCenter(width, height) {
 	const radius = Math.min(16, Math.max(8, height / 2 - 8), width / 4);
 	return {
@@ -27968,8 +28215,8 @@ function audioKeyCenter(width, height) {
 		radius
 	};
 }
-function sync$12(container, item, context) {
-	const parts = partsByContainer$12.get(container);
+function sync$13(container, item, context) {
+	const parts = partsByContainer$13.get(container);
 	if (!parts) return;
 	positionShell(parts.root, item);
 	const { width, height } = item.frame;
@@ -28040,7 +28287,7 @@ const audioCardRenderer = {
 			roundPixels: true
 		});
 		root.addChild(plate, wave, title);
-		partsByContainer$12.set(root, {
+		partsByContainer$13.set(root, {
 			root,
 			plate,
 			wave,
@@ -28048,11 +28295,11 @@ const audioCardRenderer = {
 			sig: "",
 			resolution
 		});
-		if (item.type === "audio") sync$12(root, item, context);
+		if (item.type === "audio") sync$13(root, item, context);
 		return root;
 	},
 	update: (container, item, context) => {
-		if (item.type === "audio") sync$12(container, item, context);
+		if (item.type === "audio") sync$13(container, item, context);
 	},
 	renderFar: (graphics, item, context) => {
 		drawFarPlate(graphics, item.frame, {
@@ -28062,6 +28309,127 @@ const audioCardRenderer = {
 			accentAlpha: .72
 		});
 	},
+	destroy: (container) => {
+		partsByContainer$13.get(container)?.root.destroy({ children: true });
+		partsByContainer$13.delete(container);
+	}
+};
+//#endregion
+//#region ../sdk/src/board/render/renderers/model-card-renderer.ts
+const partsByContainer$12 = /* @__PURE__ */ new WeakMap();
+const INSET_RATIO = .06;
+const KEY_RADIUS = 14;
+const KEY_MARGIN = 10;
+function modelKeyCenter(width, height) {
+	const radius = Math.max(8, Math.min(KEY_RADIUS, Math.min(width, height) * .12));
+	const margin = Math.min(KEY_MARGIN, radius * .7);
+	return {
+		x: width - margin - radius,
+		y: height - margin - radius,
+		radius
+	};
+}
+function sync$12(container, item, context) {
+	const parts = partsByContainer$12.get(container);
+	if (!parts) return;
+	positionShell(parts.root, item);
+	const { width, height } = item.frame;
+	const { src, snapshot } = item.props;
+	const meta = fileMetaLine(src, snapshot?.size);
+	const title = snapshot?.title || fileStem(src);
+	syncCardTag(parts.tag, {
+		glyph: "model",
+		text: `${title} · ${meta}`,
+		width
+	}, context);
+	const key = context.assetKey(item);
+	const texture = key ? context.getTexture(key) : null;
+	const failed = Boolean(key && !texture && context.hasError(key));
+	const detailed = boardCardDetailed(context.zoom);
+	const elevation = cardElevation(context, item.id);
+	const sig = [
+		key ?? "",
+		texture ? `${texture.width}x${texture.height}` : "none",
+		failed,
+		width,
+		height,
+		elevation,
+		detailed,
+		context.themeKey
+	].join("|");
+	if (sig === parts.sig) return;
+	parts.sig = sig;
+	drawCardSurface(parts.plate.clear(), {
+		x: 0,
+		y: 0,
+		width,
+		height
+	}, context.style, {
+		fill: context.palette.surface,
+		border: context.palette.border,
+		borderAlpha: .85,
+		elevation
+	});
+	if (texture && parts.sprite.texture !== texture) parts.sprite.texture = texture;
+	parts.sprite.visible = Boolean(texture);
+	if (texture) {
+		const inset = Math.min(width, height) * INSET_RATIO;
+		const fitted = containRect(width - inset * 2, height - inset * 2, texture.width, texture.height);
+		parts.sprite.position.set(inset + fitted.x, inset + fitted.y);
+		parts.sprite.width = fitted.width;
+		parts.sprite.height = fitted.height;
+	} else {
+		const radius = Math.max(6, Math.min(28, Math.min(width, height) * .14));
+		traceCube(parts.plate, width / 2, height / 2, radius).stroke({
+			color: context.palette.muted,
+			width: 1.5,
+			alpha: failed ? .35 : .6,
+			join: "round",
+			cap: "round"
+		});
+	}
+	parts.chrome.clear();
+	if (detailed) {
+		const center = modelKeyCenter(width, height);
+		drawModelKey(parts.chrome, center.x, center.y, center.radius, context);
+	}
+}
+const modelCardRenderer = {
+	id: "model-card",
+	canRender: (item) => isBoardModelItem(item),
+	create: (item, context) => {
+		const root = new Container();
+		const plate = new Graphics();
+		const sprite = new Sprite(Texture.EMPTY);
+		const chrome = new Graphics();
+		const tag = createCardTag();
+		root.addChild(plate, sprite, chrome, tag.root);
+		partsByContainer$12.set(root, {
+			root,
+			plate,
+			sprite,
+			chrome,
+			tag,
+			sig: ""
+		});
+		if (item.type === "file") sync$12(root, item, context);
+		return root;
+	},
+	update: (container, item, context) => {
+		if (item.type === "file") sync$12(container, item, context);
+	},
+	zoom: (container, zoom) => {
+		const tag = partsByContainer$12.get(container)?.tag;
+		if (tag) zoomCardTag(tag, zoom);
+	},
+	renderFar: (graphics, item, context) => {
+		drawFarPlate(graphics, item.frame, {
+			fill: context.palette.surface,
+			fillAlpha: .96,
+			accent: context.palette.legendary,
+			accentAlpha: .45
+		});
+	},
 	destroy: (container) => {
 		partsByContainer$12.get(container)?.root.destroy({ children: true });
 		partsByContainer$12.delete(container);
@@ -30212,6 +30580,7 @@ const builtinCardRenderers = [
 	imageCardRenderer,
 	videoCardRenderer,
 	audioCardRenderer,
+	modelCardRenderer,
 	fileCardRenderer,
 	taskCardRenderer,
 	shapeCardRenderer,

package/dist/commands/generations.js

@@ -1,7 +1,7 @@
 import { openAsBlob } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, join } from "node:path";
-import { GenerationPolicyError, assertGenerationRequestAllowedByPolicy, parseGenerationPolicyFromEnv, } from "@neta-art/cohub";
+import { GenerationPolicyError, assertGenerationRequestAllowedByPolicy, mimeTypeForPath, parseGenerationPolicyFromEnv, } from "@neta-art/cohub";
 import { probeMediaInfo } from "@neta-art/cohub/media";
 import { createClient } from "../client.js";
 import { resolveSpace } from "../space.js";
@@ -14,19 +14,6 @@ const rolesByMediaType = {
     audio: new Set(["reference_audio"]),
 };
 const mediaRoles = new Set([...frameMediaRoles, ...referenceMediaRoles]);
-const mimeByExt = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".webp": "image/webp",
-    ".gif": "image/gif",
-    ".mp4": "video/mp4",
-    ".webm": "video/webm",
-    ".mov": "video/quicktime",
-    ".mp3": "audio/mpeg",
-    ".wav": "audio/wav",
-    ".ogg": "audio/ogg",
-};
 function parseValue(value) {
     const trimmed = value.trim();
     if (trimmed === "true")
@@ -84,8 +71,8 @@ async function mediaContent({ type, value, role }, upload) {
     const block = (source) => ({ type, source, ...(role ? { meta: { role } } : {}) });
     if (/^https?:\/\//.test(value))
         return block({ type: "url", url: value });
-    const mediaType = mimeByExt[extname(value).toLowerCase()];
-    if (mediaType && upload) {
+    const mediaType = mimeTypeForPath(value);
+    if (mediaType && /^(image|video|audio)\//.test(mediaType) && upload) {
         try {
             return block({ type: "url", url: await upload(value, mediaType) });
         }
@@ -189,11 +176,13 @@ function slugOutputLabel(block) {
     return slugify(metaRole(block) ?? block.type);
 }
 const PROBE_TIMEOUT_MS = 3_000;
-/** Size, duration, and frames of URL outputs, probed in parallel; best effort. */
+/** Size, duration, and frames of image, video, and audio URL outputs, probed in parallel; best effort. */
 async function probeOutputs(output) {
     const signal = AbortSignal.timeout(PROBE_TIMEOUT_MS);
     const probed = await Promise.all(output.map(async (block, index) => {
-        if (block.type === "text" || block.source.type !== "url")
+        if (block.type !== "image" && block.type !== "video" && block.type !== "audio")
+            return null;
+        if (block.source.type !== "url")
             return null;
         const info = await probeMediaInfo(block.source.url, { type: block.type, signal });
         return Object.keys(info).length > 0 ? { index, ...info } : null;

package/dist/commands/public.d.ts

@@ -1,4 +1,4 @@
-import type { CohubHttpClient } from "@neta-art/cohub";
+import { type CohubHttpClient } from "@neta-art/cohub";
 import type { Command } from "commander";
 type LocalPublicFile = {
     id: string;

package/dist/commands/public.js

@@ -1,45 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { lstat, readdir } from "node:fs/promises";
-import { basename, extname, relative, resolve } from "node:path";
+import { basename, relative, resolve } from "node:path";
+import { isTextMime, mimeTypeForPath, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { HttpPutError, putLocalFile } from "../http-put.js";
 import { error, handleHttp, json as outJson, jsonRequested } from "../output.js";
 import { resolveSpace } from "../space.js";
 const UPLOAD_CONCURRENCY = 4;
-const MIME_TYPES = {
-    ".aac": "audio/aac",
-    ".avi": "video/x-msvideo",
-    ".avif": "image/avif",
-    ".css": "text/css; charset=utf-8",
-    ".csv": "text/csv; charset=utf-8",
-    ".gif": "image/gif",
-    ".htm": "text/html; charset=utf-8",
-    ".html": "text/html; charset=utf-8",
-    ".ico": "image/x-icon",
-    ".jpeg": "image/jpeg",
-    ".jpg": "image/jpeg",
-    ".js": "text/javascript; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".m4a": "audio/mp4",
-    ".md": "text/markdown; charset=utf-8",
-    ".mov": "video/quicktime",
-    ".mp3": "audio/mpeg",
-    ".mp4": "video/mp4",
-    ".ogg": "audio/ogg",
-    ".ogv": "video/ogg",
-    ".pdf": "application/pdf",
-    ".png": "image/png",
-    ".svg": "image/svg+xml",
-    ".txt": "text/plain; charset=utf-8",
-    ".wasm": "application/wasm",
-    ".wav": "audio/wav",
-    ".webm": "video/webm",
-    ".webp": "image/webp",
-    ".woff": "font/woff",
-    ".woff2": "font/woff2",
-    ".xml": "application/xml; charset=utf-8",
-    ".zip": "application/zip",
-};
 function hasControlCharacters(value) {
     return [...value].some((char) => {
         const code = char.charCodeAt(0);
@@ -65,8 +32,11 @@ function normalizePublicPath(input) {
     }
     return parts.join("/");
 }
-function mimeTypeForPath(path) {
-    return MIME_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
+function contentTypeForPath(path) {
+    const mimeType = mimeTypeForPath(path);
+    if (!mimeType)
+        return "application/octet-stream";
+    return isTextMime(mimeType) ? `${mimeType}; charset=utf-8` : mimeType;
 }
 async function walkDirectory(root, directory, destination) {
     const names = await readdir(directory);
@@ -90,7 +60,7 @@ async function walkDirectory(root, directory, destination) {
             localPath,
             publicPath,
             size: info.size,
-            mimeType: mimeTypeForPath(localPath),
+            mimeType: contentTypeForPath(localPath),
         });
     }
     return files;
@@ -114,7 +84,7 @@ export async function collectPublicUpload(source, destination) {
                     localPath,
                     publicPath,
                     size: info.size,
-                    mimeType: mimeTypeForPath(localPath),
+                    mimeType: contentTypeForPath(localPath),
                 }],
         };
     }

package/dist/commands/rooms-rtc-binary.js

@@ -7,7 +7,7 @@ import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
 // Pin a global release tag after its helper artifacts are published.
-export const RTC_HELPER_VERSION = "v2.67.0";
+export const RTC_HELPER_VERSION = "v2.68.0";
 const MAX_BINARY_BYTES = 128 * 1024 * 1024;
 async function digest(path) {
     const hash = createHash("sha256");

package/dist/space-files/upload.js

@@ -1,30 +1,13 @@
 import { randomUUID } from "node:crypto";
-import { UPLOAD_MAX_BATCH_BYTES, UPLOAD_MAX_BATCH_FILES, } from "@neta-art/cohub";
+import { batchUploadEntries } from "@neta-art/cohub";
 import { putLocalFile } from "../http-put.js";
 import { createLimiter } from "./limit.js";
 const PUT_CONCURRENCY = 4;
-function batches(entries) {
-    const result = [];
-    let batch = [];
-    let bytes = 0;
-    for (const entry of entries) {
-        if (batch.length > 0 && (batch.length >= UPLOAD_MAX_BATCH_FILES || bytes + entry.size > UPLOAD_MAX_BATCH_BYTES)) {
-            result.push(batch);
-            batch = [];
-            bytes = 0;
-        }
-        batch.push(entry);
-        bytes += entry.size;
-    }
-    if (batch.length > 0)
-        result.push(batch);
-    return result;
-}
 export async function uploadLocalFiles(files, entries, options = {}) {
     const uploaded = [];
     const uploadIds = [];
     const limit = createLimiter(PUT_CONCURRENCY);
-    for (const batch of batches(entries)) {
+    for (const batch of batchUploadEntries(entries, (entry) => entry.size)) {
         const byId = new Map(batch.map((entry) => [randomUUID(), entry]));
         const plan = await files.createUpload({
             destination: { kind: "workspace", targetDir: options.targetDir },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.4.1",
+  "version": "10.4.2",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,8 +18,8 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "11.3.1",
-    "@neta-art/generation": "^0.1.35",
+    "@neta-art/cohub": "11.3.2",
+    "@neta-art/generation": "^0.1.38",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
     "ws": "^8.21.3"