create-windy 0.8.3 → 0.9.1

package/template/apps/agent-server/plugins/settings/settings.test.ts

@@ -0,0 +1,129 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { runInNewContext } from "node:vm";
+import { Window, type HTMLElement } from "happy-dom";
+import { nativeProfile } from "../../native/profile";
+import { defaultHostFixture } from "../../native/host-test-fixture.js";
+
+function setup() {
+  const window = new Window();
+  let client!: {
+    apply(ctx: {
+      slots: {
+        inject(name: string, callback: () => void): void;
+        register(row: { name: string; id?: string }, render: () => null): void;
+      };
+      effect(callback: () => unknown, label: string): void;
+    }): void;
+    mountConfigurationWrap(pre: HTMLElement): () => void;
+    observeConfiguration(): () => void;
+  };
+  Object.assign(window, {
+    __ModuleLoader__: {
+      load: (definition: { factory(): typeof client }) => {
+        client = definition.factory();
+      },
+    },
+  });
+  runInNewContext(readFileSync(new URL("client.js", import.meta.url), "utf8"), {
+    window,
+    document: window.document,
+    MutationObserver: window.MutationObserver,
+  });
+  return { window, document: window.document, client };
+}
+
+test("deployment preserves guarded settings and names the preset Windy Agent", () => {
+  const profile = nativeProfile(
+    {
+      appRoot: "/app",
+      gateUrl: "http://gate",
+      model: "model",
+      contextWindow: 32768,
+      maxOutputTokens: 1024,
+    },
+    defaultHostFixture,
+  );
+  for (const id of [
+    "ui-settings-account",
+    "ui-settings-session-log",
+    "session-log-deepseek",
+    "open-in-app",
+  ])
+    expect(profile).toContainEqual({ id, disabled: true });
+  const insert = profile.find((row) => "insert" in row)! as {
+    insert: { id: string; config?: unknown }[];
+  };
+  expect(
+    insert.insert.find((row) => row.id === "preset-windy")!.config,
+  ).toMatchObject({ id: "windy", name: "Windy Agent" });
+});
+
+test("settings adds no blank preset navigation entry or hero shadow", () => {
+  const { client } = setup();
+  const rows: { name: string; id?: string }[] = [];
+  client.apply({
+    slots: {
+      inject: (_name, callback) => callback(),
+      register: (row) => {
+        rows.push(row);
+      },
+    },
+    effect() {},
+  });
+  expect(rows.map((row) => row.name)).toEqual([
+    "settings.general.item",
+    "settings.action",
+  ]);
+  expect(rows.every((row) => row.id !== undefined)).toBe(true);
+});
+
+test("wrap button sits beside its preview, supports click and Alt+Z, restores on dispose", () => {
+  const { window, document, client } = setup();
+  document.body.innerHTML =
+    '<div role="dialog"><pre>long configuration</pre></div>';
+  const pre = document.querySelector("pre")!;
+  const dispose = client.mountConfigurationWrap(pre);
+  const button = document.querySelector("button")!;
+  expect(pre.previousElementSibling?.contains(button)).toBe(true);
+  expect(button.getAttribute("aria-label")).toBe("配置换行");
+  expect(button.getAttribute("aria-pressed")).toBe("true");
+  expect(pre.style.whiteSpace).toBe("pre-wrap");
+  button.click();
+  expect(button.getAttribute("aria-pressed")).toBe("false");
+  expect(pre.style.whiteSpace).toBe("pre");
+  window.dispatchEvent(
+    new window.KeyboardEvent("keydown", {
+      altKey: true,
+      code: "KeyZ",
+      cancelable: true,
+    }),
+  );
+  expect(pre.style.whiteSpace).toBe("pre-wrap");
+  window.dispatchEvent(
+    new window.KeyboardEvent("keydown", {
+      altKey: true,
+      code: "KeyZ",
+      isComposing: true,
+    }),
+  );
+  expect(pre.style.whiteSpace).toBe("pre-wrap");
+  dispose();
+  expect(document.querySelector("button")).toBeNull();
+  expect(pre.style.whiteSpace).toBe("");
+  window.close();
+});
+
+test("observer binds late dialogs once and cleans up closed dialogs", async () => {
+  const { window, document, client } = setup();
+  const dispose = client.observeConfiguration();
+  document.body.innerHTML = '<div role="dialog"><pre>config</pre></div>';
+  await window.happyDOM.waitUntilComplete();
+  expect(document.querySelectorAll("button")).toHaveLength(1);
+  document.querySelector("pre")!.textContent = "updated config";
+  await window.happyDOM.waitUntilComplete();
+  expect(document.querySelectorAll("button")).toHaveLength(1);
+  dispose();
+  expect(document.querySelector("button")).toBeNull();
+  window.close();
+});

package/template/apps/agent-server/plugins/settings-controller.d.mts

@@ -0,0 +1,4 @@
+import SettingsController from "@deepseek-ai/dsh-api-settings-controller";
+export default class WindySettingsController extends SettingsController {
+  openSettingsDocument(): Promise<never>;
+}

package/template/apps/agent-server/plugins/settings-controller.mjs

@@ -0,0 +1,31 @@
+import SettingsController from "@deepseek-ai/dsh-api-settings-controller";
+import { RemoteError } from "@deepseek-ai/dsh-typert-protocol";
+
+/** Keep upstream settings and credential contracts; a managed server has no desktop editor. */
+export default class WindySettingsController extends SettingsController {
+  constructor(ctx) {
+    // Keep the public opener seam closed as well as the Remote-facing method,
+    // including future upstream code that calls its own implementation directly.
+    super(ctx, { openTextFile: denyOpening });
+  }
+  async openSettingsDocument() {
+    return denyOpening();
+  }
+  async write(ns, ...args) {
+    if (ns === "agent-preset-registry")
+      throw new RemoteError(
+        "remote-access/denied",
+        "Windy Agent 预设由产品固定，不允许修改。",
+        {},
+      );
+    return super.write(ns, ...args);
+  }
+}
+
+async function denyOpening() {
+  throw new RemoteError(
+    "remote-access/denied",
+    "Windy部署不允许打开服务器配置文件。请使用设置页面。",
+    {},
+  );
+}

package/template/apps/agent-server/plugins/settings-controller.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from "bun:test";
+import SettingsController from "@deepseek-ai/dsh-api-settings-controller";
+import WindySettingsController from "./settings-controller.mjs";
+
+test("managed settings reject native file opening before provider access", async () => {
+  const controller = Object.create(WindySettingsController.prototype);
+  Object.defineProperty(controller, "ctx", {
+    get() {
+      throw new Error("must not prepare a file or spawn an editor");
+    },
+  });
+  await expect(controller.openSettingsDocument()).rejects.toMatchObject({
+    code: "remote-access/denied",
+  });
+  expect(controller.describe).toBe(SettingsController.prototype.describe);
+  expect(controller.update).toBe(SettingsController.prototype.update);
+});

package/template/apps/agent-server/plugins/settings-dispatch.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { Context } from "@deepseek-ai/cordis";
+import {
+  TypertRegistry,
+  type TypertContribution,
+} from "@deepseek-ai/dsh-typert-registry";
+import { TypertGatewayService } from "@deepseek-ai/dsh-api-gateway";
+import { TYPERT } from "@deepseek-ai/dsh-api-settings-controller/typert";
+import { Peer } from "@deepseek-ai/dsh-client-connection";
+import WindySettingsController from "./settings-controller.mjs";
+
+test("generated upstream Remote dispatch enforces managed settings denial", async () => {
+  const ctx = new Context();
+  const registry = new TypertRegistry(ctx);
+  // The pinned generated module deliberately declares its public value unknown;
+  // the real registry validates this contribution when registering its codecs.
+  registry.register(TYPERT as TypertContribution);
+  new WindySettingsController(ctx);
+  const gateway = new TypertGatewayService(ctx, {});
+  const peer = new Peer(ctx, { principal: { kind: "owner" } });
+  try {
+    await expect(
+      gateway.invoke({
+        namespace: "settings",
+        method: "openSettingsDocument",
+        args: {},
+        peer,
+      }),
+    ).rejects.toMatchObject({ code: "remote-access/denied" });
+  } finally {
+    await peer.dispose();
+    await ctx.fiber.dispose();
+  }
+});

package/template/apps/agent-server/plugins/shared-skills.d.mts

@@ -0,0 +1,15 @@
+import type { SkillProvider } from "@deepseek-ai/dsh-skill";
+
+export interface ManagedPublishedSkill {
+  readonly key: string;
+  readonly version: number;
+  readonly digest: string;
+  readonly root: string;
+  readonly markdown: string;
+}
+
+export function sharedSkillProvider(
+  fetchItems: (
+    signal?: AbortSignal,
+  ) => Promise<readonly ManagedPublishedSkill[]>,
+): SkillProvider;

package/template/apps/agent-server/plugins/shared-skills.mjs

@@ -0,0 +1,82 @@
+import { skillDocument } from "./skill-library/bundle.mjs";
+
+export const name = "windy-shared-skills";
+export const inject = ["skills"];
+
+export function sharedSkillProvider(fetchItems) {
+  const provider = "windy-published";
+  const definition = (item) => {
+    const parsed = skillDocument(item.markdown);
+    return {
+      name: parsed.name,
+      description: parsed.description,
+      provider,
+      source: "windy-published",
+      invocation: {
+        modelInvocable: parsed.modelInvocable,
+        userInvocable: parsed.userInvocable,
+      },
+      resourceBase: { kind: "directory", path: item.root },
+      path: `${item.root}/SKILL.md`,
+      content: item.markdown.replace(
+        /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/,
+        "",
+      ),
+      metadata: { displayName: parsed.displayName },
+    };
+  };
+  return {
+    name: provider,
+    async list(options) {
+      const items = await fetchItems(options.signal);
+      return {
+        // Current access and enabled versions are checked on every lookup.
+        complete: false,
+        candidates: items.map((item) => ({
+          ...definition(item),
+          rank: 50,
+          locator: {
+            key: item.key,
+            version: item.version,
+            digest: item.digest,
+          },
+        })),
+      };
+    },
+    async get(candidate, options) {
+      const items = await fetchItems(options.signal);
+      const locator = candidate.locator;
+      const item = items.find(
+        (row) =>
+          row.key === locator?.key &&
+          row.version === locator.version &&
+          row.digest === locator.digest,
+      );
+      return item ? definition(item) : undefined;
+    },
+  };
+}
+
+export function apply(ctx) {
+  const gate = process.env.WINDY_GATE_URL,
+    token = process.env.WINDY_WORKER_TOKEN;
+  if (!gate || !token) throw new Error("Missing managed worker binding");
+  ctx.skills.registerProvider((control) =>
+    sharedSkillProvider(async (signal) => {
+      const response = await fetch(`${gate}/skills`, {
+        headers: { authorization: `Bearer ${token}` },
+        signal: AbortSignal.any([
+          control.signal,
+          ...(signal ? [signal] : []),
+          AbortSignal.timeout(5000),
+        ]),
+        redirect: "error",
+      });
+      if (!response.ok) throw new Error("SHARED_SKILLS_UNAVAILABLE");
+      const result = await response.json();
+      if (!Array.isArray(result.items))
+        throw new Error("INVALID_SHARED_SKILLS");
+      return result.items;
+    }),
+  );
+}

package/template/apps/agent-server/plugins/shared-skills.test.ts

@@ -0,0 +1,51 @@
+import { expect, test } from "bun:test";
+import {
+  sharedSkillProvider,
+  type ManagedPublishedSkill,
+} from "./shared-skills.mjs";
+
+const markdown =
+  "---\nname: governed-review\ndescription: 核对授权材料\ndisable-model-invocation: true\n---\n读取 references/check.md 并核验来源。\n";
+const first: ManagedPublishedSkill = {
+  key: "governed-review",
+  version: 1,
+  digest: `sha256:${"a".repeat(64)}`,
+  root: "/data/agent/managed-skills/actor-a/version-a",
+  markdown,
+};
+
+test("published provider reauthorizes every discovery/read and rejects a changed or disabled version", async () => {
+  let calls = 0;
+  let items = [first];
+  const provider = sharedSkillProvider(async () => {
+    calls++;
+    return items;
+  });
+  const observed = await provider.list({});
+  if (Array.isArray(observed) || !("candidates" in observed))
+    throw new Error("Expected uncached provider observation");
+  expect(observed.complete).toBe(false);
+  const candidate = observed.candidates[0]!;
+  expect(candidate.invocation).toEqual({
+    modelInvocable: false,
+    userInvocable: true,
+  });
+  const definition = await provider.get(candidate, {});
+  expect(definition?.resourceBase).toEqual({
+    kind: "directory",
+    path: first.root,
+  });
+  expect(definition?.content).toContain("references/check.md");
+  items = [{ ...first, version: 2, digest: `sha256:${"b".repeat(64)}` }];
+  expect(await provider.get(candidate, {})).toBeUndefined();
+  items = [];
+  expect(await provider.get(candidate, {})).toBeUndefined();
+  expect(calls).toBe(4);
+});
+
+test("unknown authorization fails closed without a cached skill body", async () => {
+  const provider = sharedSkillProvider(async () => {
+    throw new Error("UNAUTHENTICATED");
+  });
+  await expect(provider.list({})).rejects.toThrow("UNAUTHENTICATED");
+});

package/template/apps/agent-server/plugins/skill-library/README.md

@@ -0,0 +1,11 @@
+# 个人技能管理
+
+通过官方DSH插件、slots与Skill provider，在侧栏提供个人技能查看、创建、编辑、SKILL.md/ZIP导入、导出、删除及显式方法沉淀。默认技能目录只读，个人文件位于当前工作区 `.dsh/skills`。
+
+技能包限制：归档4 MiB、展开总量16 MiB、单文件4 MiB、Markdown128 KiB、条目128；拒绝路径穿越、符号链接、特殊文件、重复路径、隐藏文件和压缩炸弹。保存以摘要版本做冲突检查，目录操作绑定真实inode，不允许跨用户读写。
+
+用户明确要求沉淀方法时才调用 `save_workflow_skill`；模型提供通用输入、步骤、输出及核验，完整内容经用户确认后保存。同名不覆盖，业务资料及凭据不写入方法。辅助生成仅返回供用户审阅的草稿，不自动执行或共享。
+
+草稿生成使用受控模型、90秒超时和输出上限，成功返回 `x-windy-skill-draft-complete: 1` 供Product Host重授权并记录审计。浏览器不能自报成功审计。
+
+Client通过公开ui-primitives与模块加载器工作，主入口和client.*.js文件必须整体部署以保持revision一致。关闭个人扩展不会卸载已经保存的插件。

package/template/apps/agent-server/plugins/skill-library/archive.test.ts

@@ -0,0 +1,43 @@
+import { expect, test } from "bun:test";
+import { zipSync, strToU8 } from "fflate";
+import { fixture, markdown } from "./test-fixture.js";
+
+test("reject lying ZIP inflated sizes, excessive entries and disabled deployment", async () => {
+  const f = await fixture();
+  const archive = zipSync({
+    "SKILL.md": strToU8(markdown()),
+    "assets/bomb": new Uint8Array(5 * 1024 * 1024),
+  });
+  const view = new DataView(archive.buffer);
+  for (let offset = 0; offset < archive.length - 46; offset++) {
+    if (
+      view.getUint32(offset, true) === 0x02014b50 &&
+      view.getUint32(offset + 24, true) > 1024 * 1024
+    )
+      view.setUint32(offset + 24, 1, true);
+  }
+  expect(
+    (
+      await f.call({
+        action: "import",
+        archive: Buffer.from(archive).toString("base64"),
+      })
+    ).status,
+  ).toBe(413);
+  const excessive: Record<string, Uint8Array> = {
+    "SKILL.md": strToU8(markdown()),
+  };
+  for (let i = 0; i < 129; i++) excessive[`assets/file-${i}`] = strToU8("data");
+  expect(
+    (
+      await f.call({
+        action: "import",
+        archive: Buffer.from(zipSync(excessive)).toString("base64"),
+      })
+    ).status,
+  ).toBe(400);
+  f.config.enabled = false;
+  expect((await f.call({ action: "create", raw: markdown() })).status).toBe(
+    403,
+  );
+});

package/template/apps/agent-server/plugins/skill-library/bundle.mjs

@@ -0,0 +1,234 @@
+import { Unzip, UnzipInflate, zipSync, strToU8 } from "fflate";
+import { parseDocument } from "yaml";
+
+export const LIMITS = {
+  archive: 4 * 1024 * 1024,
+  total: 16 * 1024 * 1024,
+  file: 4 * 1024 * 1024,
+  markdown: 128 * 1024,
+  entries: 128,
+};
+export function fail(message, status = 400) {
+  throw Object.assign(new Error(message), { status });
+}
+export function skillName(value) {
+  if (
+    typeof value !== "string" ||
+    !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value) ||
+    value.length > 64
+  )
+    fail("技能标识须为小写英文、数字和连字符，最长 64 字符。");
+  return value;
+}
+export function skillDocument(raw) {
+  if (
+    typeof raw !== "string" ||
+    Buffer.byteLength(raw) > LIMITS.markdown ||
+    raw.includes("\0")
+  )
+    fail("技能正文无效或超过 128 KiB。");
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/.exec(raw);
+  if (!match) fail("SKILL.md 需要 YAML 头部（name、description）及正文。");
+  const doc = parseDocument(match[1], { uniqueKeys: true });
+  if (doc.errors.length) fail("技能 YAML 格式无效。");
+  let meta;
+  try {
+    meta = doc.toJS({ maxAliasCount: 20 });
+  } catch {
+    fail("技能 YAML 引用过多。");
+  }
+  const name = skillName(meta?.name);
+  if (
+    typeof meta.description !== "string" ||
+    !meta.description.trim() ||
+    meta.description.length > 2048 ||
+    !match[2].trim()
+  )
+    fail("请填写技能说明和正文。");
+  for (const field of ["user-invocable", "disable-model-invocation"])
+    if (meta[field] !== undefined && typeof meta[field] !== "boolean")
+      fail(`${field} 必须为 true 或 false。`);
+  const displayName = meta.metadata?.displayName;
+  if (
+    displayName !== undefined &&
+    (typeof displayName !== "string" ||
+      !displayName.trim() ||
+      displayName.length > 60 ||
+      [...displayName].some(
+        (char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127,
+      ))
+  )
+    fail("技能中文名称须为 1–60 个字符的单行文字。");
+  return {
+    name,
+    description: meta.description,
+    userInvocable: meta["user-invocable"] !== false,
+    modelInvocable: meta["disable-model-invocation"] !== true,
+    ...(displayName ? { displayName: displayName.trim() } : {}),
+  };
+}
+export function safeEntry(name) {
+  if (
+    typeof name !== "string" ||
+    name.length > 240 ||
+    name.includes("\\") ||
+    name.startsWith("/") ||
+    [...name].some(
+      (char) =>
+        char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127 || char === ":",
+    )
+  )
+    fail("技能包包含非法路径。");
+  const parts = name.replace(/\/$/, "").split("/");
+  if (parts.some((part) => !part || part.startsWith(".") || part.length > 100))
+    fail("技能包不能包含隐藏路径、父目录或空路径。");
+  return name;
+}
+
+// Validate the central directory before any decompression. Reject ZIP64, encryption,
+// duplicate paths and Unix symlinks; never trust advertised inflated size alone.
+export function inspectZip(bytes) {
+  if (bytes.length > LIMITS.archive || bytes.length < 22)
+    fail("ZIP 超过 4 MiB 或格式无效。", 413);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let end = bytes.length - 22;
+  while (
+    end >= Math.max(0, bytes.length - 65557) &&
+    view.getUint32(end, true) !== 0x06054b50
+  )
+    end--;
+  if (end < 0 || end < bytes.length - 65557) fail("ZIP 目录无效。");
+  const count = view.getUint16(end + 10, true),
+    start = view.getUint32(end + 16, true);
+  if (
+    view.getUint16(end + 4, true) ||
+    view.getUint16(end + 6, true) ||
+    count !== view.getUint16(end + 8, true) ||
+    !count ||
+    count > LIMITS.entries ||
+    start + view.getUint32(end + 12, true) !== end
+  )
+    fail("ZIP 文件数量或分卷格式不支持。");
+  let cursor = start,
+    total = 0;
+  const names = new Map();
+  for (let i = 0; i < count; i++) {
+    if (cursor + 46 > end || view.getUint32(cursor, true) !== 0x02014b50)
+      fail("ZIP 目录损坏。");
+    const size = view.getUint32(cursor + 24, true),
+      length = view.getUint16(cursor + 28, true),
+      extra = view.getUint16(cursor + 30, true),
+      comment = view.getUint16(cursor + 32, true);
+    if (
+      cursor + 46 + length + extra + comment > end ||
+      view.getUint16(cursor + 8, true) & 1 ||
+      ![0, 8].includes(view.getUint16(cursor + 10, true)) ||
+      ((view.getUint32(cursor + 38, true) >>> 16) & 0xf000) === 0xa000
+    )
+      fail("ZIP 包含加密、符号链接或不支持的压缩方式。");
+    const name = safeEntry(
+      new TextDecoder("utf-8", { fatal: true }).decode(
+        bytes.subarray(cursor + 46, cursor + 46 + length),
+      ),
+    );
+    const key = name.replace(/\/$/, "").toLowerCase();
+    if (names.has(key) || size > LIMITS.file || (total += size) > LIMITS.total)
+      fail("ZIP 路径重复或展开体积过大。", 413);
+    names.set(key, { name, size });
+    cursor += 46 + length + extra + comment;
+  }
+  if (cursor !== end) fail("ZIP 目录不完整。");
+  return names;
+}
+export function decodeBundle(bytes) {
+  const advertised = inspectZip(bytes),
+    files = Object.create(null),
+    seen = new Set();
+  let expanded = 0,
+    failure;
+  const archive = new Unzip((entry) => {
+    const name = safeEntry(entry.name),
+      known = advertised.get(name.replace(/\/$/, "").toLowerCase());
+    if (!known || known.name !== name || seen.has(name))
+      fail("ZIP 本地目录与中央目录不一致。");
+    seen.add(name);
+    const chunks = [];
+    let size = 0;
+    entry.ondata = (error, chunk, final) => {
+      if (error) {
+        failure = error;
+        entry.terminate();
+        return;
+      }
+      size += chunk.length;
+      expanded += chunk.length;
+      if (size > known.size || size > LIMITS.file || expanded > LIMITS.total) {
+        failure = Object.assign(new Error("ZIP 展开体积超限。"), {
+          status: 413,
+        });
+        entry.terminate();
+        return;
+      }
+      chunks.push(chunk);
+      if (final && !name.endsWith("/")) {
+        if (size !== known.size) {
+          failure = new Error("ZIP 文件长度不一致。");
+          return;
+        }
+        const output = new Uint8Array(size);
+        let offset = 0;
+        for (const part of chunks) {
+          output.set(part, offset);
+          offset += part.length;
+        }
+        files[name] = output;
+      }
+    };
+    entry.start();
+  });
+  archive.register(UnzipInflate);
+  for (let offset = 0; offset < bytes.length; offset += 1024) {
+    archive.push(
+      bytes.subarray(offset, offset + 1024),
+      offset + 1024 >= bytes.length,
+    );
+    if (failure) throw failure;
+  }
+  if (seen.size !== advertised.size) fail("ZIP 文件目录不完整。");
+  const keys = Object.keys(files),
+    markdown = keys.filter(
+      (name) => name === "SKILL.md" || /^[^/]+\/SKILL\.md$/.test(name),
+    );
+  if (markdown.length !== 1) fail("ZIP 必须只包含一个技能目录及其 SKILL.md。");
+  const prefix = markdown[0].slice(0, -8),
+    result = Object.create(null);
+  let total = 0;
+  for (const key of keys) {
+    if (
+      !key.startsWith(prefix) ||
+      key === prefix ||
+      (total += files[key].length) > LIMITS.total ||
+      files[key].length > LIMITS.file
+    )
+      fail("ZIP 含技能目录之外的文件或体积过大。", 413);
+    result[safeEntry(key.slice(prefix.length))] = files[key];
+  }
+  const raw = new TextDecoder("utf-8", { fatal: true }).decode(
+    result["SKILL.md"],
+  );
+  return { ...skillDocument(raw), files: result };
+}
+export function markdownBundle(raw) {
+  return { ...skillDocument(raw), files: { "SKILL.md": strToU8(raw) } };
+}
+export function encodeBundle(name, files) {
+  return zipSync(
+    Object.fromEntries(
+      Object.entries(files).map(([path, bytes]) => [
+        `${name}/${safeEntry(path)}`,
+        bytes,
+      ]),
+    ),
+    { level: 6 },
+  );
+}