test(assets): grouped 경로 전략 검증 테스트 추가

README.md

@@ -34,3 +34,61 @@ You can check out [the Next.js GitHub repository](https://github.com/vercel/next
 The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
 
 Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
+
+## Export Bundle (Landing ZIP)
+
+The Builder can export a production-ready ZIP that contains:
+
+- index.html, styles.css, app.js
+- assets/ hashed assets (optionally grouped by type)
+- site.webmanifest, robots.txt
+- Optional: sheets/ (Google Apps Script template)
+- Metadata files: assets.json, assets.index.json
+
+### Export Options UI
+
+- Manifest
+  - Name, Short Name, Start URL, Display (dropdown), Theme Color (HEX only)
+- Robots
+  - Disallow lines (textarea). Each line becomes a `Disallow:` rule.
+- Google Sheets Template Mode
+  - Auto: include when `form.actionUrl` is empty
+  - Include: always include
+  - Exclude: never include
+
+### site.webmanifest and robots.txt
+
+- `site.webmanifest` is derived from page data; Export Options can override fields.
+- `robots.txt` defaults to a permissive header and adds `Disallow` lines from UI.
+
+### Asset paths and grouping
+
+- AssetManager writes files to `assets/` with stable hash-based filenames.
+- Path strategy can be configured:
+  - `flat` (default): `assets/<hash>.<ext>`
+  - `grouped`: `assets/images/...`, `assets/fonts/...`, `assets/other/...`
+
+### assets.json
+
+Structured metadata for all assets. Example fields per entry:
+
+- originalName, mimeType, size
+- hash8, ext, zipPath
+- integrity: `sha256-<base64>` (placeholder, base64 of bytes)
+- group: `images|fonts|other`
+- referencedAt: array of `local:<originalName>` when referenced by the page
+
+### assets.index.json
+
+Simple index to quickly find assets by group:
+
+- images: string[] of zip paths
+- fonts: string[] of zip paths
+- other: string[] of zip paths
+
+### Google Sheets template (optional)
+
+- When included, ZIP contains:
+  - `sheets/Code.gs`: minimal Apps Script handler (Web App)
+  - `sheets/README.txt`: setup instructions
+- Inclusion is controlled by `sheetsMode` (Auto/Include/Exclude) and `form.actionUrl` in Auto mode.

components/BuilderClientPage.tsx

@@ -8,6 +8,7 @@ import { AssetManager } from '@/lib/assets/assetManager'
 import { buildZip } from '@/lib/exporter/zip'
 import { buildExtrasForPage } from '@/lib/exporter/extras'
 import { buildAssetsMetadata } from '@/lib/exporter/assets.meta'
+import { buildAssetsIndex } from '@/lib/exporter/assets.index'
 import type { Section } from '@/lib/state/store'
 import { createFormStore, type FormState } from '@/lib/state/formStore'
 import FormBuilderPanel from '@/components/FormBuilderPanel'
@@ -56,6 +57,10 @@ export default function BuilderClientPage() {
   const [manifestDisplay, setManifestDisplay] = useState<string>('')
   const [manifestThemeColor, setManifestThemeColor] = useState<string>('')
   const [robotsDisallow, setRobotsDisallow] = useState<string>('')
+  const [sheetsMode, setSheetsMode] = useState<'auto' | 'include' | 'exclude'>('auto')
+  const [assetPathStrategy, setAssetPathStrategy] = useState<'flat' | 'grouped'>('flat')
+  // Font optimization: allow toggling Google Fonts preconnect links in exported HTML
+  const [fontPreconnect, setFontPreconnect] = useState<boolean>(true)
   const [viewport, setViewport] = useState<'desktop' | 'mobile'>(() => {
     if (typeof window !== 'undefined') {
       try {
@@ -174,9 +179,22 @@ export default function BuilderClientPage() {
     try {
       if (typeof window !== 'undefined') {
         const w = window as unknown as { __exportPreview?: () => { html: string; css: string; js: string } }
+        // Build an effective AssetManager based on selected path strategy
+        const buildEffectiveAm = (): AssetManager | undefined => {
+          const base = am ?? undefined
+          if (!base) return undefined
+          if (assetPathStrategy === 'flat') return base
+          const clone = new AssetManager({ maxBytes: 10 * 1024 * 1024, allowedExts: ['png', 'jpg', 'jpeg', 'webp', 'svg'], pathStrategy: assetPathStrategy })
+          for (const ref of base.list()) {
+            // re-add to apply new path strategy and recreate byOriginal mapping
+            clone.add({ name: ref.originalName, type: ref.mimeType, bytes: ref.bytes })
+          }
+          return clone
+        }
         w.__exportPreview = () => {
           try {
-            return exportPage(pageSchema.parse(pageData), { assetManager: am ?? undefined })
+            // Export preview with current optimization options
+            return exportPage(pageSchema.parse(pageData), { assetManager: buildEffectiveAm(), fontPreconnect })
           } catch {
             const fixed: Page = {
               ...pageData,
@@ -186,12 +204,12 @@ export default function BuilderClientPage() {
                 spamProtection: pageData.form?.spamProtection ?? { honeypotFieldName: '_hp', minSubmitSeconds: 2 },
               },
             }
-            return exportPage(pageSchema.parse(fixed), { assetManager: am ?? undefined })
+            return exportPage(pageSchema.parse(fixed), { assetManager: buildEffectiveAm(), fontPreconnect })
           }
         }
       }
     } catch {}
-  }, [pageData, am])
+  }, [pageData, am, fontPreconnect, assetPathStrategy])
 
   const doExport = useCallback(async () => {
     let valid = pageData as Page
@@ -208,7 +226,19 @@ export default function BuilderClientPage() {
       } as Page
       valid = pageSchema.parse(fixed)
     }
-    const exported = exportPage(valid, { assetManager: am ?? undefined })
+    // Build an effective AssetManager based on selected path strategy
+    const buildEffectiveAm = (): AssetManager | undefined => {
+      const base = am ?? undefined
+      if (!base) return undefined
+      if (assetPathStrategy === 'flat') return base
+      const clone = new AssetManager({ maxBytes: 10 * 1024 * 1024, allowedExts: ['png', 'jpg', 'jpeg', 'webp', 'svg'], pathStrategy: assetPathStrategy })
+      for (const ref of base.list()) {
+        clone.add({ name: ref.originalName, type: ref.mimeType, bytes: ref.bytes })
+      }
+      return clone
+    }
+    // Respect font optimization toggle when exporting
+    const exported = exportPage(valid, { assetManager: buildEffectiveAm(), fontPreconnect })
     try {
       if (typeof window !== 'undefined') {
         const w = window as unknown as { __captureExport?: boolean; __lastExport?: { html: string; css: string; js: string } }
@@ -217,7 +247,17 @@ export default function BuilderClientPage() {
         }
       }
     } catch {}
-    const assets = am ? am.toZipStructure() : {}
+    const effectiveAm = (() => {
+      const base = am ?? undefined
+      if (!base) return undefined
+      if (assetPathStrategy === 'flat') return base
+      const clone = new AssetManager({ maxBytes: 10 * 1024 * 1024, allowedExts: ['png', 'jpg', 'jpeg', 'webp', 'svg'], pathStrategy: assetPathStrategy })
+      for (const ref of base.list()) {
+        clone.add({ name: ref.originalName, type: ref.mimeType, bytes: ref.bytes })
+      }
+      return clone
+    })()
+    const assets = effectiveAm ? effectiveAm.toZipStructure() : {}
     // Build overrides from UI options
     const manifestOverrideBase: Record<string, string> = {}
     if (manifestName && manifestName.trim().length > 0) manifestOverrideBase.name = manifestName.trim()
@@ -238,14 +278,14 @@ export default function BuilderClientPage() {
       const disallowLines = lines.map((l) => (l.startsWith('Disallow:') ? l : `Disallow: ${l}`))
       return `User-agent: *\n${disallowLines.join('\n')}`
     })()
-    const baseExtras = buildExtrasForPage(valid, { robotsText: robotsTextOverride, manifest: manifestOverride })
+    const baseExtras = buildExtrasForPage(valid, { robotsText: robotsTextOverride, manifest: manifestOverride, sheetsMode })
     const extras: Record<string, Uint8Array> = {
       ...baseExtras,
-      ...(am ? { 'assets.json': buildAssetsMetadata(am) } : {}),
+      ...(am ? { 'assets.json': buildAssetsMetadata(am), 'assets.index.json': buildAssetsIndex(am) } : {}),
     }
     const zipBytes = await buildZip({ html: exported.html, css: exported.css, js: exported.js, assets, extras })
     download('landing.zip', zipBytes)
-  }, [pageData, am, manifestName, manifestShortName, manifestStartUrl, manifestDisplay, manifestThemeColor, robotsDisallow])
+  }, [pageData, am, manifestName, manifestShortName, manifestStartUrl, manifestDisplay, manifestThemeColor, robotsDisallow, sheetsMode, fontPreconnect, assetPathStrategy])
 
   return (
     <div className="p-6 space-y-6">
@@ -310,6 +350,31 @@ export default function BuilderClientPage() {
             </div>
             <div className="border rounded p-3 space-y-2">
               <h2 className="text-sm font-semibold mb-1">Export Options</h2>
+              {/* Asset path strategy: flat vs grouped */}
+              <label className="block" htmlFor="ins-asset-path-strategy">
+                <span className="sr-only">Asset Path Strategy</span>
+                <select
+                  id="ins-asset-path-strategy"
+                  aria-label="Asset Path Strategy"
+                  className="border rounded px-3 py-2 w-full"
+                  value={assetPathStrategy}
+                  onChange={(e) => setAssetPathStrategy(e.target.value as 'flat' | 'grouped')}
+                >
+                  <option value="flat">Assets Path: Flat</option>
+                  <option value="grouped">Assets Path: Grouped (images/fonts/other)</option>
+                </select>
+              </label>
+              {/* Font optimization toggle for Google Fonts preconnect */}
+              <label className="flex items-center gap-2" htmlFor="ins-font-preconnect">
+                <input
+                  id="ins-font-preconnect"
+                  type="checkbox"
+                  aria-label="Font Preconnect"
+                  checked={fontPreconnect}
+                  onChange={(e) => setFontPreconnect(e.target.checked)}
+                />
+                <span className="text-sm">Enable font preconnect (Google Fonts)</span>
+              </label>
               <label className="block" htmlFor="ins-manifest-name">
                 <span className="sr-only">Manifest Name</span>
                 <input
@@ -381,6 +446,20 @@ export default function BuilderClientPage() {
                   placeholder="/private\n/tmp"
                 />
               </label>
+              <label className="block" htmlFor="ins-sheets-mode">
+                <span className="sr-only">Google Sheets Template Mode</span>
+                <select
+                  id="ins-sheets-mode"
+                  aria-label="Google Sheets Template Mode"
+                  className="border rounded px-3 py-2 w-full"
+                  value={sheetsMode}
+                  onChange={(e) => setSheetsMode(e.target.value as 'auto'|'include'|'exclude')}
+                >
+                  <option value="auto">Sheets Template: Auto</option>
+                  <option value="include">Sheets Template: Include</option>
+                  <option value="exclude">Sheets Template: Exclude</option>
+                </select>
+              </label>
             </div>
           </div>
         }

lib/assets/assetManager.grouped.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect } from 'vitest'
+import { AssetManager } from '@/lib/assets/assetManager'
+
+function u8(n: number): Uint8Array { const a = new Uint8Array(n); for (let i=0;i<n;i++) a[i]=i&0xff; return a }
+
+describe('AssetManager pathStrategy grouped', () => {
+  it('writes assets under assets/images and assets/fonts when grouped', async () => {
+    const am = new AssetManager({ maxBytes: 1024*1024, allowedExts: ['png','woff2'], pathStrategy: 'grouped' })
+    const img = await am.add({ name: 'hero.png', type: 'image/png', bytes: u8(10) })
+    const font = await am.add({ name: 'main.woff2', type: 'font/woff2', bytes: u8(12) })
+    expect(img.path).toMatch(/^assets\/images\/[0-9a-f]{8}\.png$/)
+    expect(font.path).toMatch(/^assets\/fonts\/[0-9a-f]{8}\.woff2$/)
+    const zip = am.toZipStructure()
+    const keys = Object.keys(zip)
+    expect(keys.some(k => /^assets\/images\//.test(k))).toBe(true)
+    expect(keys.some(k => /^assets\/fonts\//.test(k))).toBe(true)
+  })
+
+  it('rewriteUrl marks referenced originals and returns grouped path', async () => {
+    const am = new AssetManager({ maxBytes: 1024*1024, allowedExts: ['png'], pathStrategy: 'grouped' })
+    const img = await am.add({ name: 'hero.png', type: 'image/png', bytes: u8(10) })
+    const rewritten = am.rewriteUrl('local:hero.png')
+    expect(rewritten).toBe(img.path)
+    expect(am.referencedList()).toContain('hero.png')
+  })
+})

lib/assets/assetManager.ts

@@ -16,6 +16,7 @@ export type AssetRef = {
 export type AssetManagerOptions = {
   maxBytes: number
   allowedExts: string[] // e.g., ['png','jpg','jpeg','webp','svg']
+  pathStrategy?: 'flat' | 'grouped'
 }
 
 function extOf(name: string): string {
@@ -36,12 +37,15 @@ function hash8(bytes: Uint8Array): string {
 export class AssetManager {
   private readonly maxBytes: number
   private readonly allowed: Set<string>
+  private readonly pathStrategy: 'flat' | 'grouped'
   private byHash = new Map<string, AssetRef>()
   private byOriginal = new Map<string, string>() // originalName -> path
+  private referenced = new Set<string>() // originalName referenced via rewrite
 
   constructor(opts: AssetManagerOptions) {
     this.maxBytes = opts.maxBytes
     this.allowed = new Set(opts.allowedExts.map((e) => e.toLowerCase()))
+    this.pathStrategy = opts.pathStrategy ?? 'flat'
   }
 
   async add(file: AssetInput): Promise<AssetRef> {
@@ -60,7 +64,7 @@ export class AssetManager {
       return existing
     }
 
-    const path = `assets/${h}.${ext}`
+    const path = this.makePath(h, ext, file.type)
     const ref: AssetRef = {
       originalName: file.name,
       mimeType: file.type,
@@ -91,8 +95,23 @@ export class AssetManager {
     if (urlOrLocalRef.startsWith('local:')) {
       const key = urlOrLocalRef.slice('local:'.length)
       const p = this.byOriginal.get(key)
+      if (p) this.referenced.add(key)
       return p ?? urlOrLocalRef
     }
     return urlOrLocalRef
   }
+
+  referencedList(): string[] {
+    return Array.from(this.referenced)
+  }
+
+  private makePath(hash8: string, ext: string, mime: string): string {
+    if (this.pathStrategy === 'grouped') {
+      let group = 'other'
+      if (mime.startsWith('image/')) group = 'images'
+      else if (mime.startsWith('font/')) group = 'fonts'
+      return `assets/${group}/${hash8}.${ext}`
+    }
+    return `assets/${hash8}.${ext}`
+  }
 }

lib/exporter/assets.index.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { AssetManager } from '@/lib/assets/assetManager'
+import { buildAssetsIndex } from '@/lib/exporter/assets.index'
+
+function u8(n: number): Uint8Array { const a = new Uint8Array(n); for (let i=0;i<n;i++) a[i]=i&0xff; return a }
+
+describe('Assets index builder', () => {
+  it('groups assets by mime into images/fonts/other and lists zipPath', async () => {
+    const am = new AssetManager({ maxBytes: 1024*1024, allowedExts: ['png','woff2','txt'] })
+    await am.add({ name: 'a.png', type: 'image/png', bytes: u8(4) })
+    await am.add({ name: 'b.woff2', type: 'font/woff2', bytes: u8(6) })
+    await am.add({ name: 'c.txt', type: 'text/plain', bytes: u8(2) })
+    const bytes = buildAssetsIndex(am)
+    const obj = JSON.parse(new TextDecoder().decode(bytes)) as { images: string[]; fonts: string[]; other: string[] }
+    expect(obj.images.length).toBe(1)
+    expect(obj.fonts.length).toBe(1)
+    expect(obj.other.length).toBe(1)
+    expect(obj.images[0]).toMatch(/^assets\/[0-9a-f]{8}\.png$/)
+    expect(obj.fonts[0]).toMatch(/^assets\/[0-9a-f]{8}\.woff2$/)
+    expect(obj.other[0]).toMatch(/^assets\/[0-9a-f]{8}\.txt$/)
+  })
+})

lib/exporter/assets.index.ts

@@ -0,0 +1,21 @@
+import type { AssetManager } from '@/lib/assets/assetManager'
+
+export type AssetsIndex = {
+  images: string[]
+  fonts: string[]
+  other: string[]
+}
+
+export function buildAssetsIndex(am: AssetManager): Uint8Array {
+  const images: string[] = []
+  const fonts: string[] = []
+  const other: string[] = []
+  for (const ref of am.list()) {
+    if (ref.mimeType.startsWith('image/')) images.push(ref.path)
+    else if (ref.mimeType.startsWith('font/')) fonts.push(ref.path)
+    else other.push(ref.path)
+  }
+  const obj: AssetsIndex = { images, fonts, other }
+  const json = JSON.stringify(obj, null, 2)
+  return new TextEncoder().encode(json)
+}

lib/exporter/assets.meta.ts

@@ -8,13 +8,22 @@ export type AssetMetaItem = {
   ext: string
   zipPath: string
   integrity: string
+  group: 'images' | 'fonts' | 'other'
+  referencedAt: string[]
 }
 
 export function buildAssetsMetadata(am: AssetManager): Uint8Array {
   const list = am.list()
+  const referenced = new Set(am.referencedList())
   const items: AssetMetaItem[] = list.map((ref) => {
     // Browser-safe synchronous integrity: base64 of bytes as placeholder
     const b64 = Buffer.from(ref.bytes).toString('base64')
+    const group: 'images' | 'fonts' | 'other' = ref.mimeType.startsWith('image/')
+      ? 'images'
+      : ref.mimeType.startsWith('font/')
+      ? 'fonts'
+      : 'other'
+    const referencedAt = referenced.has(ref.originalName) ? [`local:${ref.originalName}`] : []
     return {
       originalName: ref.originalName,
       mimeType: ref.mimeType,
@@ -23,6 +32,8 @@ export function buildAssetsMetadata(am: AssetManager): Uint8Array {
       ext: ref.ext,
       zipPath: ref.path,
       integrity: `sha256-${b64}`,
+      group,
+      referencedAt,
     }
   })
   const json = JSON.stringify({ assets: items }, null, 2)

lib/exporter/assets.pathStrategy.integration.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest'
+import { exportPage } from '@/lib/exporter/html'
+import { pageSchema, type Page } from '@/lib/schema/page'
+import { AssetManager } from '@/lib/assets/assetManager'
+
+function makePage(): Page {
+  return pageSchema.parse({
+    title: 'Path Strategy',
+    locale: 'en',
+    theme: { primaryColor: '#2563eb', fontFamily: 'Inter' },
+    sections: [ { type: 'hero', props: { heading: 'Hello', subheading: 'World', imageUrl: 'local:hero.png' } } ],
+    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
+    seo: { title: 't', description: 'd' },
+  })
+}
+
+describe('자산 경로 구조 옵션', () => {
+  it('grouped 전략일 때 이미지가 assets/images/ 경로로 렌더된다', async () => {
+    const page = makePage()
+    const am = new AssetManager({ maxBytes: 1024 * 1024, allowedExts: ['png'], pathStrategy: 'grouped' })
+    // add hero image asset
+    const bytes = new Uint8Array([1,2,3,4,5])
+    await am.add({ name: 'hero.png', type: 'image/png', bytes })
+    const out = exportPage(page, { assetManager: am })
+    expect(out.html).toMatch(/assets\/images\/[a-f0-9]{8}\.png/i)
+  })
+})

lib/exporter/extras.autoEnrich.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest'
+import { buildExtrasForPage } from '@/lib/exporter/extras'
+import { pageSchema, type Page } from '@/lib/schema/page'
+
+function makePage(): Page {
+  return pageSchema.parse({
+    title: 'My Product',
+    locale: 'en',
+    theme: { primaryColor: '#0ea5e9', fontFamily: 'Inter' },
+    sections: [ { type: 'hero', props: { heading: 'Hello', subheading: '', imageUrl: 'https://example.com/hero.png' } } ],
+    form: { actionUrl: '', fields: [], spamProtection: { honeypotFieldName: '_hp', minSubmitSeconds: 2 } },
+    seo: { title: 't', description: 'd' },
+  })
+}
+
+function toStr(bytes: Uint8Array) {
+  return new TextDecoder().decode(bytes)
+}
+
+describe('extras 자동 보강', () => {
+  it('manifest: 잘못된 theme_color는 무시하고 기본(primaryColor) 사용', () => {
+    const page = makePage()
+    const out = buildExtrasForPage(page, { manifest: { theme_color: 'not-a-hex' } })
+    const manifest = JSON.parse(toStr(out['site.webmanifest']))
+    expect(manifest.theme_color).toBe('#0ea5e9')
+  })
+
+  it('manifest: short_name은 12자 이내로 자동 절단', () => {
+    const page = makePage()
+    const out = buildExtrasForPage(page, { manifest: { name: 'Super Long Product Name' } })
+    const manifest = JSON.parse(toStr(out['site.webmanifest']))
+    expect(manifest.short_name.length).toBeLessThanOrEqual(12)
+  })
+
+  it('robots: 주어진 plain 경로 목록을 자동으로 User-agent 헤더와 Disallow 라인으로 보강', () => {
+    const page = makePage()
+    const robotsPlain = "/admin\n/private"
+    const out = buildExtrasForPage(page, { robotsText: robotsPlain })
+    const robots = toStr(out['robots.txt'])
+    expect(robots).toMatch(/^User-agent: \*/)
+    expect(robots).toMatch(/Disallow: \/admin/)
+    expect(robots).toMatch(/Disallow: \/private/)
+  })
+})

lib/exporter/extras.ts

@@ -9,6 +9,7 @@ export type ExtrasOverrides = {
     display: string
     theme_color: string
   }>
+  sheetsMode?: 'auto' | 'include' | 'exclude'
 }
 
 function toBytes(s: string): Uint8Array {
@@ -16,7 +17,14 @@ function toBytes(s: string): Uint8Array {
 }
 
 function buildRobots(base?: string): string {
-  if (base && base.trim().length > 0) return base
+  if (base && base.trim().length > 0) {
+    const s = base.trim()
+    if (/^User-agent:/i.test(s)) return s
+    const lines = s.split(/\n+/).map((l) => l.trim()).filter((l) => l.length > 0)
+    if (lines.length === 0) return 'User-agent: *\n'
+    const disallowLines = lines.map((l) => (l.startsWith('Disallow:') ? l : `Disallow: ${l}`))
+    return `User-agent: *\n${disallowLines.join('\n')}`
+  }
   return 'User-agent: *\n'
 }
 
@@ -36,16 +44,27 @@ export function buildExtrasForPage(page: Page, overrides?: ExtrasOverrides): Rec
   const robotsText = buildRobots(overrides?.robotsText)
   out['robots.txt'] = toBytes(robotsText)
 
-  // site.webmanifest
+  // site.webmanifest (auto-enrich and safe-merge)
   const manifestBase = deriveManifest(page)
-  const manifestMerged = { ...manifestBase, ...(overrides?.manifest || {}) }
+  const ov = overrides?.manifest || {}
+  const name = ov.name && ov.name.trim().length > 0 ? ov.name : manifestBase.name
+  const short_name = ov.short_name && ov.short_name.trim().length > 0
+    ? ov.short_name
+    : (name.length > 12 ? name.slice(0, 12) : name)
+  const start_url = ov.start_url && ov.start_url.trim().length > 0 ? ov.start_url : manifestBase.start_url
+  const display = ov.display && ov.display.trim().length > 0 ? ov.display : manifestBase.display
+  const hexOk = ov.theme_color ? /^#([0-9a-fA-F]{3}){1,2}$/.test(ov.theme_color) : false
+  const theme_color = hexOk ? (ov.theme_color as string) : manifestBase.theme_color
+  const manifestMerged = { name, short_name, start_url, display, theme_color }
   const manifestJson = JSON.stringify(manifestMerged, null, 2)
   out['site.webmanifest'] = toBytes(manifestJson)
 
-  // Google Sheets 템플릿: actionUrl 미지정 시 포함
+  // Google Sheets 템플릿: 기본 auto. overrides.sheetsMode로 강제 포함/제외 가능
+  const mode = overrides?.sheetsMode ?? 'auto'
   const action = page.form?.actionUrl?.trim()
   const hasAction = !!(action && action.length > 0)
-  if (!hasAction) {
+  const shouldInclude = mode === 'include' || (mode === 'auto' && !hasAction)
+  if (shouldInclude) {
     const code = `/**
  * Google Apps Script Web App for form submissions
  * - Deploy as Web App and set URL as form action if needed.

lib/exporter/html.ts

@@ -2,7 +2,7 @@ import type { Page, FormField } from '@/lib/schema/page'
 import type { AssetManager } from '@/lib/assets/assetManager'
 
 export type Exported = { html: string; css: string; js: string }
-export type ExportOptions = { assetManager?: AssetManager }
+export type ExportOptions = { assetManager?: AssetManager; fontPreconnect?: boolean }
 
 function renderFaq(section: { props: { items: Array<{ q: string; a: string }> } }) {
   const itemsRaw: Array<{ q: string; a: string }> = Array.isArray(section.props.items) ? section.props.items : []
@@ -222,7 +222,7 @@ function renderForm(page: Page) {
   `
 }
 
-function buildHead(page: Page) {
+function buildHead(page: Page, opts?: ExportOptions) {
   const ogImage = page.seo.ogImage
   const analyticsParts: string[] = []
   const ga = page.analytics?.ga4MeasurementId
@@ -250,11 +250,13 @@ function buildHead(page: Page) {
     </script>`)
   }
   const custom = page.analytics?.customHeadHtml || ''
+  const preconnect = opts?.fontPreconnect !== false
   return `
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <link rel="canonical" href="/" />
-    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    ${preconnect ? '<link rel="preconnect" href="https://fonts.googleapis.com" />' : ''}
+    ${preconnect ? '<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />' : ''}
     <link rel="manifest" href="/site.webmanifest" />
     <meta name="theme-color" content="${escapeHtml(page.theme.primaryColor)}" />
     <title>${escapeHtml(page.seo.title)}</title>
@@ -338,9 +340,7 @@ export function exportPage(page: Page, opts?: ExportOptions): Exported {
   const html = `<!DOCTYPE html>
 <html lang="${escapeHtml(page.locale)}">
 <head>
-${buildHead(page)}
-<link rel="preconnect" href="https://fonts.googleapis.com">
-<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+${buildHead(page, opts)}
 </head>
 <body>
   <a href="#main" class="skip-link">Skip to content</a>