@gmickel/gno 1.31.0 → 1.33.0

package/spec/output-schemas/publish-artifact.schema.json

@@ -16,6 +16,10 @@
         "egressLineage": { "$ref": "#/definitions/egressLineage" },
         "source": { "$ref": "#/definitions/slug" },
         "exportedAt": { "type": "string", "format": "date-time" },
+        "requiredCapabilities": {
+          "$ref": "#/definitions/requiredCapabilities"
+        },
+        "assets": { "$ref": "#/definitions/assets" },
         "spaces": {
           "type": "array",
           "minItems": 1,
@@ -37,6 +41,9 @@
         "egressLineage": { "$ref": "#/definitions/egressLineage" },
         "source": { "$ref": "#/definitions/slug" },
         "exportedAt": { "type": "string", "format": "date-time" },
+        "requiredCapabilities": {
+          "$ref": "#/definitions/requiredCapabilities"
+        },
         "spaces": {
           "type": "array",
           "minItems": 1,
@@ -44,6 +51,74 @@
         }
       }
     },
+    "requiredCapabilities": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 128
+      }
+    },
+    "assets": {
+      "type": "array",
+      "items": { "$ref": "#/definitions/artifactAsset" }
+    },
+    "artifactAsset": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "mediaType",
+        "byteLength",
+        "sha256",
+        "width",
+        "height",
+        "encoding",
+        "data",
+        "references"
+      ],
+      "properties": {
+        "id": { "$ref": "#/definitions/hash" },
+        "mediaType": {
+          "enum": [
+            "image/png",
+            "image/jpeg",
+            "image/gif",
+            "image/webp",
+            "image/avif"
+          ]
+        },
+        "byteLength": { "type": "integer", "minimum": 1, "maximum": 104857600 },
+        "sha256": { "$ref": "#/definitions/hash" },
+        "width": { "type": "integer", "minimum": 1, "maximum": 16384 },
+        "height": { "type": "integer", "minimum": 1, "maximum": 16384 },
+        "encoding": { "const": "base64" },
+        "data": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 139810134,
+          "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
+        },
+        "references": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": ["noteSlug", "sourceRef"],
+            "properties": {
+              "noteSlug": { "$ref": "#/definitions/slug" },
+              "sourceRef": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 1024
+              }
+            }
+          }
+        }
+      }
+    },
     "slug": {
       "type": "string",
       "pattern": "^[a-z0-9](?:[a-z0-9-]{0,78}[a-z0-9])?$",
@@ -280,7 +355,7 @@
             "ciphertext": {
               "type": "string",
               "minLength": 1,
-              "maxLength": 67108864,
+              "maxLength": 104857600,
               "pattern": "^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
             },
             "iterations": {

package/src/cli/commands/publish.ts

@@ -4,7 +4,8 @@
  * @module src/cli/commands/publish
  */
 
-import { mkdir, writeFile } from "node:fs/promises";
+// node:fs/promises — directory creation has no Bun-native equivalent.
+import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import { join } from "node:path";
 
@@ -12,10 +13,15 @@ import type {
   PublishArtifact,
   PublishVisibility,
 } from "../../publish/artifact";
+import type { PublishAssetEgressSummary } from "../../publish/attachment-resolver";
 import type { SanitizeWarning } from "../../publish/obsidian-sanitize";
 
 import { resolveDownloadsDir } from "../../core/user-dirs";
-import { derivePublishArtifactFilename, slugify } from "../../publish/artifact";
+import {
+  derivePublishArtifactFilename,
+  serializePublishArtifact,
+  slugify,
+} from "../../publish/artifact";
 import { exportPublishArtifact } from "../../publish/export-service";
 import { formatSanitizeWarnings } from "../../publish/obsidian-sanitize";
 import { initStore } from "./shared";
@@ -37,6 +43,7 @@ export type PublishExportResult =
       success: true;
       data: {
         artifact: PublishArtifact;
+        assetSummary: PublishAssetEgressSummary;
         outPath: string;
         preview?: string;
         uploadUrl: string;
@@ -64,6 +71,15 @@ export async function buildDefaultPublishExportPath(
   );
 }
 
+/** Write exactly the canonical byte sequence used by upload-size accounting. */
+export async function writePublishArtifactFile(
+  outPath: string,
+  artifact: PublishArtifact
+): Promise<void> {
+  await mkdir(dirname(outPath), { recursive: true });
+  await Bun.write(outPath, serializePublishArtifact(artifact));
+}
+
 export async function publishExport(
   target: string,
   options: PublishExportOptions
@@ -79,7 +95,7 @@ export async function publishExport(
   const { collections, store } = initResult;
 
   try {
-    const { artifact, warnings } = await exportPublishArtifact({
+    const { artifact, assetSummary, warnings } = await exportPublishArtifact({
       collections,
       options: {
         routeSlug: options.slug,
@@ -104,6 +120,7 @@ export async function publishExport(
         success: true,
         data: {
           artifact,
+          assetSummary,
           outPath: "",
           preview,
           uploadUrl: "https://gno.sh/studio",
@@ -116,13 +133,13 @@ export async function publishExport(
     const outPath =
       options.out?.trim() || (await buildDefaultPublishExportPath(artifact));
 
-    await mkdir(dirname(outPath), { recursive: true });
-    await writeFile(outPath, JSON.stringify(artifact, null, 2));
+    await writePublishArtifactFile(outPath, artifact);
 
     return {
       success: true,
       data: {
         artifact,
+        assetSummary,
         outPath,
         uploadUrl: "https://gno.sh/studio",
         warnings,
@@ -159,19 +176,37 @@ export function formatPublishExport(
     return JSON.stringify(result.data, null, 2);
   }
 
-  const { artifact, outPath, preview, uploadUrl, warningsDisplay } =
-    result.data;
+  const {
+    artifact,
+    assetSummary,
+    outPath,
+    preview,
+    uploadUrl,
+    warningsDisplay,
+  } = result.data;
   const space = artifact.spaces[0];
   const warningsSection =
     warningsDisplay.length > 0
       ? ["", "Preprocessor notes:", ...warningsDisplay]
       : [];
+  const assetSection = [
+    "",
+    "Asset summary:",
+    `  assets=${assetSummary.assetCount} refs=${assetSummary.referenceCount} external=${assetSummary.externalCount}`,
+    `  rawBytes=${assetSummary.rawBytes} encodedBytes=${assetSummary.encodedBytes} finalBytes=${assetSummary.finalUploadBytes}`,
+    `  dedupSavedBytes=${assetSummary.dedupSavedBytes} unresolved=${assetSummary.diagnostics.length}`,
+    ...assetSummary.diagnostics.map(
+      (diagnostic) =>
+        `  [${diagnostic.code}] ${diagnostic.noteSlug}: ${diagnostic.sourceRef} — ${diagnostic.message}`
+    ),
+  ];
 
   if (preview !== undefined) {
     return [
       `Preview (no file written) — ${space?.sourceType ?? "artifact"}`,
       `Route slug: ${space?.routeSlug ?? slugify(artifact.source)}`,
       `Visibility: ${space?.visibility ?? "public"}`,
+      ...assetSection,
       ...warningsSection,
       "",
       "─── sanitized markdown ───",
@@ -185,6 +220,7 @@ export function formatPublishExport(
     `Visibility: ${space?.visibility ?? "public"}`,
     `Filename: ${derivePublishArtifactFilename(artifact)}`,
     `Next: open ${uploadUrl} and drop ${outPath} into the upload zone.`,
+    ...assetSection,
     ...warningsSection,
   ].join("\n");
 }

package/src/core/document-capabilities.ts

@@ -24,6 +24,19 @@ function isTextLikeMime(mime: string): boolean {
   return mime.startsWith("text/");
 }
 
+/**
+ * True when a document may carry markdown/wiki/HTML references in mirror text.
+ * Used by refactor inventory completeness to fail closed on missing mirrors.
+ * Non-text binaries (pdf/images/…) are omitted — they cannot hold those refs.
+ */
+export function isTextLikeReferenceDocument(
+  sourceExt: string,
+  sourceMime: string
+): boolean {
+  const ext = sourceExt.toLowerCase();
+  return EDITABLE_EXTENSIONS.has(ext) || isTextLikeMime(sourceMime);
+}
+
 export function getDocumentCapabilities(input: {
   sourceExt: string;
   sourceMime: string;

package/src/core/file-ops.ts

@@ -27,13 +27,25 @@ export async function atomicWrite(
   }
 }
 
+type AtomicCreateContent =
+  | string
+  | Blob
+  | ArrayBuffer
+  | Uint8Array
+  | ReturnType<typeof Bun.file>;
+
+/**
+ * Exclusively create `path` via temp write + hard-link.
+ * EEXIST (including a pre-existing symlink) fails closed without following it.
+ */
 export async function atomicCreate(
   path: string,
-  content: string
+  content: AtomicCreateContent
 ): Promise<void> {
   const tempPath = `${path}.tmp.${crypto.randomUUID()}`;
   await Bun.write(tempPath, content);
   try {
+    // node:fs/promises link — exclusive create; no Bun equivalent
     await link(tempPath, path);
   } catch (e) {
     await unlink(tempPath).catch(() => {
@@ -78,6 +90,122 @@ export async function createFolderPath(path: string): Promise<void> {
   await mkdir(path, { recursive: true });
 }
 
+/** Sibling staging/backup path beside a user file (never under a different root). */
+export function siblingRefactorPath(
+  path: string,
+  kind: "stage" | "backup",
+  token: string
+): string {
+  return `${path}.gno-rf-${kind}.${token}`;
+}
+
+/**
+ * Exclusively create a stage artifact. Pre-existing symlink/file at stagePath
+ * fails closed (EEXIST) and is never followed/overwritten.
+ */
+export async function writeStagedFileContent(
+  stagePath: string,
+  content: string
+): Promise<void> {
+  await atomicCreate(stagePath, content);
+}
+
+/**
+ * Exclusively copy live bytes into a sibling backup path.
+ * Pre-existing symlink/file at backupPath fails closed (EEXIST).
+ */
+export async function backupFileToSibling(
+  sourcePath: string,
+  backupPath: string
+): Promise<void> {
+  await atomicCreate(backupPath, Bun.file(sourcePath));
+}
+
+/**
+ * Replace an existing path from a staged sibling via rename.
+ * Callers must verify live fingerprints before invoking.
+ */
+export async function commitStagedFileReplace(
+  stagePath: string,
+  targetPath: string
+): Promise<void> {
+  await rename(stagePath, targetPath);
+}
+
+/**
+ * Create a new target from a staged sibling without overwrite.
+ * Uses hard-link create semantics so an occupied target fails closed.
+ */
+export async function commitStagedFileExclusive(
+  stagePath: string,
+  targetPath: string
+): Promise<void> {
+  // node:fs/promises link — exclusive create; no Bun equivalent
+  await link(stagePath, targetPath);
+  await unlink(stagePath).catch(() => {
+    /* stage cleanup best-effort after durable target exists */
+  });
+}
+
+/** @deprecated Prefer commitStagedFileReplace / commitStagedFileExclusive. */
+export async function commitStagedFile(
+  stagePath: string,
+  targetPath: string
+): Promise<void> {
+  await commitStagedFileReplace(stagePath, targetPath);
+}
+
+/**
+ * Restore original bytes by replacing the target path itself (rename),
+ * never following a symlink that may have been swapped onto the target.
+ */
+export async function restoreFileFromBackup(
+  backupPath: string,
+  targetPath: string
+): Promise<void> {
+  const tempPath = `${targetPath}.gno-rf-restore.${crypto.randomUUID()}`;
+  await Bun.write(tempPath, Bun.file(backupPath));
+  try {
+    // node:fs/promises rename — replaces the directory entry (symlink-safe)
+    await rename(tempPath, targetPath);
+  } catch (error) {
+    await unlink(tempPath).catch(() => {
+      /* ignore cleanup errors */
+    });
+    throw error;
+  }
+}
+
+function isEnoent(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    "code" in error &&
+    (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+/** Best-effort cleanup removal; ignores all errors (never used for commit). */
+export async function removePathIfExists(path: string): Promise<void> {
+  // node:fs/promises unlink — structure op, no Bun equivalent
+  await unlink(path).catch(() => {
+    /* ignore cleanup errors */
+  });
+}
+
+/**
+ * Required removal: ignores only ENOENT. Permission/I/O failures throw so
+ * callers cannot report success with both source and target present.
+ */
+export async function removePathRequired(path: string): Promise<void> {
+  // node:fs/promises unlink — structure op, no Bun equivalent
+  try {
+    await unlink(path);
+  } catch (error) {
+    if (isEnoent(error)) return;
+    throw error;
+  }
+}
+
 type TrashFileDeps = {
   homeDir?: string;
   platform?: ReturnType<typeof getPlatform>;