#vectie/bunnia

#Package Shape

• core: platform-neutral tree, events, adapters, render planning, and generic surface-status badges/overlays for loading, stale, error, retry, cancelled, and degraded states.
• program: pure Program[Model, Msg] update/view boundary with pending effects and patch plans.
• agent: lightweight message, review, artifact-link, run-status, and communication planning primitives, plus generic communication threads and traces.
• scene: static stylised map model with layers, selectable regions, markers, asset manifests, hit targets, thread-link plans, and bounded updates.
• effects: typed frontend effect descriptions, platform support planning, snapshot-delta planning, cancel/retry helpers, and backend contract paths.
• adapters/wechat: WeChat Mini Program output generation.
• tooling: build-profile diagnostics that aggregate render, WeChat, patch, backend, snapshot-delta, agent-delta, asset, and scene budget signals.
• examples/agent_map: small downstream example combining agentic UI, review controls, patches, and a static map surface.
• examples/wenyu_overview: product-shaped proof slice that keeps Wenyu projection/view code outside the framework core.
• examples/moontown_miniapp: product-shaped Moontown mini-app vertical slice with full-screen map, building search/place flows, agent chat, mock local backend contracts, and create-building/create-agent controls outside core.
• root package: small @bunnia facade for app authors.

#Generate The Demo

moon run cmd/main -- help

moon run cmd/main

moon run cmd/main -- --out /tmp/bunnia-agent-map

moon run cmd/main -- build --target wechat --example moontown_miniapp --strict --budget large --render-budget large
moon run cmd/main -- inspect --target wechat --example moontown_miniapp --budget large --render-budget large
sh scripts/validate_moontown_ordinary_copy.sh

node examples/moontown_miniapp/backend/local_backend.mjs --reset-state
node examples/moontown_miniapp/backend/local_backend.mjs --smoke

moon run cmd/main -- build --target wechat --strict

moon run cmd/main -- build --target wechat --strict --budget tight

moon run cmd/main -- watch --target wechat --example agent_map --strict

moon run cmd/main -- snapshot --target wechat --example agent_map --strict

moon run cmd/main -- inspect --target wechat --example agent_map --budget tight --render-budget tight

moon run cmd/main -- limits --target wechat

moon run cmd/main -- ci-plan
moon run cmd/main -- ci-plan --script
sh scripts/scaffold_smoke.sh
sh scripts/ci.sh

moon run cmd/main -- ci-plan --example moontown_miniapp --budget large --render-budget large

moon run cmd/main -- build --target alipay --example agent_map --strict
moon run cmd/main -- build --target tiktok --example agent_map --strict

///|
test {
  let root = @bunnia.page([@bunnia.button("Open", "open-detail")])
  let alipay = @bunnia.generate_alipay_project(name="Adapter", root~)
  let tiktok = @bunnia.generate_tiktok_project(name="Adapter", root~)
  assert_true(alipay.files[2].path.has_suffix(".axml"))
  assert_true(tiktok.files[2].path.has_suffix(".ttml"))
  assert_eq(alipay.page.plan.node_count, tiktok.page.plan.node_count)
}

///|
test {
  let limits = @bunnia.platform_limits(target="wechat")
  assert_eq(limits.generator_status_id, "available")
  assert_eq(limits.generator_available, true)
  assert_eq(limits.event_mappings[0].platform_event, "bindtap")
  assert_eq(limits.request_mappings[0].platform_api, "wx.request")
  assert_true(limits.summary.contains("components=9"))
  let alipay = @bunnia.platform_limits(target="alipay")
  assert_eq(alipay.generator_status_id, "available")
  assert_eq(alipay.event_mappings[0].platform_event, "onTap")
  assert_eq(alipay.request_mappings[0].platform_api, "my.request")
}

#WeChat package policy

• keep the main package at or below 1.5 MiB whenever practical;
• keep every subpackage at or below 2 MiB and all subpackages at or below 30 MiB in total;
• reserve the main package for startup routes and truly boot-critical assets;
• move non-TabBar pages and large optional components into subpackages;
• serve image, audio, and video libraries from approved CDN or object-storage domains, while keeping a compact local fallback for the first screen;
• import third-party libraries by used function or module instead of bundling an entire library.

moon run cmd/main -- init --name my_miniapp --module local/my_miniapp --out /tmp/my-miniapp

moon run cmd/main -- --example wenyu_overview

///|
test {
  let page = @bunnia.page([
    @bunnia.view([
      @bunnia.text("Demo Dashboard"),
      @bunnia.button("Open Detail", "open-detail"),
    ]),
  ])
  let plan = @bunnia.plan(page, @bunnia.wechat())
  assert_eq(plan.node_count, 5)
}

///|
test {
  let plan = @bunnia.plan_scene_assets_with_budget_and_policy(
    [
      @bunnia.remote_image_asset(
        "remote-ok", "https://cdn.example.test/tile.png",
      ),
      @bunnia.remote_image_asset(
        "remote-bad", "https://assets.example.test/tile.png",
      ),
    ],
    @bunnia.default_scene_asset_budget(),
    @bunnia.scene_asset_policy(approved_remote_domains=["cdn.example.test"]),
  )
  assert_eq(plan.remote_assets, 2)
  assert_eq(plan.unapproved_remote_asset_count, 1)
}

///|
test {
  let app = @bunnia.program(
    id="counter",
    model=0,
    view=fn(count) {
      @bunnia.page([
        @bunnia.text("Count \{count}"),
        @bunnia.button("Increment", "inc"),
      ])
    },
    update=fn(count, msg) {
      if msg == "inc" {
        @bunnia.step(model=count + 1)
      } else {
        @bunnia.step(model=count)
      }
    },
  )
  let next = @bunnia.apply(app, "inc")
  let output = @bunnia.generate_wechat_page(
    "Counter",
    @bunnia.current_view(next),
  )
  assert_true(output.wxml.contains("Count 1"))
}

///|
test {
  let trace = @bunnia.communication_trace([
    @bunnia.handoff(
      id="handoff-1",
      thread_id="thread-a",
      from_actor_id="agent-a",
      to_actor_id="operator",
      text="Please review this result.",
      open_message="open-review",
    ),
  ])
  let output = @bunnia.generate_wechat_page("Trace", @bunnia.page([trace]))
  assert_true(output.wxml.contains("bunnia-communication-handoff"))
  assert_true(output.wxml.contains("open-review"))
}

///|
test {
  let runtime = @bunnia.wechat_runtime(initial_data_json="{\"counter\":0}", event_patches=[
    @bunnia.wechat_event_patch("open-detail", [@bunnia.set_json("counter", "1")]),
  ])
  let project = @bunnia.generate_wechat_project_with_runtime(
    name="Budgeted",
    root=@bunnia.page([@bunnia.button("Open", "open-detail")]),
    runtime~,
  )
  let report = @bunnia.report_wechat_project(project, runtime)
  assert_eq(report.file_count, 10)
  assert_true(project.manifest.summary.contains("app_files=9"))
  assert_true(report.initial_data_bytes > 0)
  assert_true(report.event_patch_bytes > 0)
}

///|
test {
  let contract = @bunnia.backend_contract(id="agent-backend", endpoints=[
    @bunnia.agent_message_endpoint(
      "send-agent-message", "/agent/message", "message", "messageResult",
    ),
    @bunnia.review_decision_endpoint(
      "review-decision", "/review/decision", "review", "reviewResult",
    ),
  ])
  let plan = @bunnia.plan_backend_contract(contract)
  let effects = @bunnia.plan_backend_effects_for_platform(
    contract,
    @bunnia.wechat(),
  )
  let js = @bunnia.generate_wechat_request_adapter(contract)
  assert_eq(plan.endpoint_count, 2)
  assert_eq(effects.effect_count, 2)
  assert_true(js.contains("wx.request"))
  assert_true(!js.contains("secret"))
}

///|
test {
  let plan = @bunnia.plan_snapshot_deltas([
    @bunnia.set_snapshot_section_delta(
      "home", "buildings", "[{\"id\":\"hall\"}]",
    ),
    @bunnia.append_snapshot_item_delta(
      "home", "messages", "msg-1", "{\"id\":\"msg-1\"}",
    ),
  ])
  assert_eq(plan.section_update_count, 1)
  assert_eq(plan.append_item_count, 1)
  assert_eq(plan.full_snapshot_count, 0)
  assert_true(plan.patch_plan.total_estimated_bytes < 128)
}

///|
test {
  let assets = [@bunnia.sprite_asset("agent", "/assets/agent.png", 2048)]
  let map = @bunnia.static_scene_view(
    @bunnia.scene(
      "overview",
      @bunnia.scene_size(640, 480),
      [
        @bunnia.layer("districts", 1, [], regions=[
          @bunnia.region(
            id="district-a",
            label="District A",
            x=48,
            y=64,
            width=240,
            height=160,
            status="review",
            tap_message="select-district-a",
          ),
        ]),
        @bunnia.layer("actors", 10, [
          @bunnia.marker(
            id="actor-a",
            label="Agent A",
            x=120,
            y=180,
            status="running",
            asset_ref="agent",
            tap_message="select-actor-a",
          ),
        ]),
      ],
      assets~,
    ),
  )
  let patches = @bunnia.plan_patches([
    @bunnia.select_scene_region("overview", "district-a"),
    @bunnia.set_scene_marker_status("overview", "actor-a", "selected"),
  ])
  let output = @bunnia.generate_wechat_page("Map", @bunnia.page([map]))
  assert_true(output.wxml.contains("data-region-id=\"district-a\""))
  assert_true(output.wxml.contains("bunnia-scene-sprite"))
  assert_true(patches.total_estimated_bytes < 96)
}

///|
test {
  let map = @bunnia.scene(
    "ops-map",
    @bunnia.scene_size(640, 420),
    [
      @bunnia.layer("markers", 1, [
        @bunnia.marker(
          id="agent",
          label="Agent",
          x=120,
          y=140,
          status="running",
          tap_message="select-agent",
          asset_ref="agent",
        ),
      ]),
    ],
    assets=[@bunnia.sprite_asset("agent", "/assets/agent.png", 2048)],
  )
  let quality = @bunnia.plan_scene_visual_quality(map)
  assert_eq(quality.degraded, false)
  assert_eq(quality.diagnostics.length(), 0)
}

///|
test {
  let feed = @bunnia.message_feed([
    @bunnia.message(
      id="msg-1",
      actor_id="agent-a",
      thread_id="thread-a",
      text="Working",
      artifact_ref="artifact://result-a",
    ),
  ])
  let map = @bunnia.static_scene_view(
    @bunnia.scene("overview", @bunnia.scene_size(640, 480), [
      @bunnia.layer("actors", 10, [
        @bunnia.marker(
          id="actor-a",
          label="Agent A",
          x=120,
          y=180,
          status="running",
          tap_message="select-actor-a",
        ),
      ]),
    ]),
  )
  let output = @bunnia.generate_wechat_page("Demo", @bunnia.page([feed, map]))
  assert_true(output.wxml.contains("select-actor-a"))
  assert_true(output.js.contains("__bunnia.lastMessage"))
}