@synopackageland/cli 0.4.0 → 0.5.0

package/dist/templates/native-go-vue/frontend/test/m2-ui.test.ts

@@ -0,0 +1,209 @@
+// @vitest-environment jsdom
+import {expect,test,vi} from 'vitest'
+import {createApp,h,nextTick} from 'vue'
+import {AppRoot} from '@synopackageland/ui'
+import {mount} from '../src/m2-main'
+import M2PathPicker from '../src/nas/M2PathPicker.vue'
+import {M2_MAX_BYTES,M2ProviderKey,type M2Provider} from '../src/nas/m2-contract'
+import {m2Copy,m2Catalogs,m2ErrorCopy} from '../src/nas/m2-i18n'
+import {format} from '../src/nas/i18n'
+import {shellCopy} from '../src/shell/i18n'
+import type {Context} from '../src/context'
+vi.stubGlobal('URL',Object.assign(URL,{createObjectURL:vi.fn(()=> 'blob:local-test'),revokeObjectURL:vi.fn()}))
+const id='a'.repeat(64)
+async function settle(){for(let i=0;i<20;i++){await Promise.resolve();await nextTick()}await new Promise(r=>setTimeout(r,25))}
+function click(root:HTMLElement,text:string){const b=[...root.querySelectorAll('button')].find(b=>b.textContent?.trim()===text||b.getAttribute('aria-label')===text);expect(b,text).toBeTruthy();b!.click()}
+function fixture(locale='en'){
+ let user='normal1',selections:any[]=[],failure=''
+ const reopen:Array<()=>void>=[]
+ const call=vi.fn(async(method:string,args?:Record<string,unknown>)=>{
+  if(failure&&method.startsWith('nas.'))throw {code:failure,message:'Cookie=secret /private'}
+  if(method==='app.status')return {package:'SamePackage',version:'1',user,admin:false}
+  if(method==='nas.session.status')return {mode:'filestation-session',interactive:'session-required',background:'unavailable',validation:'local-only'}
+  if(method==='nas.discovery')return {files:args?.folder?[]:null,shares:args?.folder?undefined:[{name:'Home',path:'/home',isdir:true}],total:args?.folder?0:1,offset:0}
+  if(method==='nas.grants.list')return selections
+  if(method==='nas.grants.confirm'){const s={grantId:id,folder:args!.folder,writable:args!.writable};selections.push(s);return s}
+  if(method==='nas.grants.revoke'){selections=[];return {revoked:true}}
+  if(method==='nas.files.list')return {files:[{name:'notes.txt',path:'/home/notes.txt',isdir:false,additional:{size:3}}],total:1,offset:0}
+  if(method==='nas.files.stat')return {name:'notes.txt',path:'/home/notes.txt',isdir:false,additional:{size:3}}
+  if(method==='nas.files.read')return {data:'YWJj',bytes:3}
+  if(method==='nas.files.create')return {created:true}
+  if(method==='nas.files.write')return {written:true}
+  throw {code:'unknown_method'}
+ })
+ const ctx={locale,call,reopen(fn:()=>void){reopen.push(fn);return ()=>{}}} as Context
+ const root=document.createElement('div');document.body.append(root);const app=mount(root,ctx)
+ return {root,app,call,reopen,setUser(value:string){user=value},fail(code:string){failure=code},close(){app.unmount();root.remove()}}
+}
+test('the File Station build uses the same DSM sidebar with a status page',async()=>{
+ const f=fixture(),copy=shellCopy('en')
+ try{
+  await settle()
+  const labels=[...f.root.querySelectorAll<HTMLElement>('[data-nav-item]')].map(node=>node.textContent?.trim())
+  expect(labels).toEqual([copy.status,copy.folders])
+  expect(f.root.querySelector('h1')?.textContent?.trim()).toBe(copy.status)
+  const folders=[...f.root.querySelectorAll<HTMLElement>('[data-nav-item]')].find(node=>node.textContent?.trim()===copy.folders)!
+  folders.click();await settle()
+  expect(f.root.querySelector('h1')?.textContent?.trim()).toBe(copy.folders)
+  expect(f.root.textContent).toContain(m2Copy('en').ownPermissions)
+ }finally{f.close()}
+})
+
+test('real session routes drive browse, writable consent, file actions and revoke without helper approval',async()=>{
+ const f=fixture(),copy=m2Copy('en')
+ try{
+  await settle();expect(f.root.textContent).toContain(copy.ownPermissions);expect(f.root.textContent).toContain(copy.unsupported)
+  click(f.root,copy.choose);await settle();click(f.root,'Select Home');await settle()
+  const checkbox=f.root.querySelector<HTMLElement>('[role=checkbox]')!;checkbox.click()
+  click(f.root,copy.confirm);await settle()
+  expect(f.call).toHaveBeenCalledWith('nas.grants.confirm',{folder:'/home',writable:true})
+  click(f.root,copy.openFiles);await settle();click(f.root,copy.inspect);await settle()
+  expect(f.root.textContent).toContain('3');click(f.root,copy.read);await settle()
+  expect(f.root.textContent).toContain(copy.readComplete)
+  const labelled=(text:string)=>f.root.querySelector<HTMLElement>(`#${[...f.root.querySelectorAll('label')].find(l=>l.textContent?.startsWith(text))!.htmlFor}`)
+  expect(labelled(copy.folderName)).toBe(f.root.querySelector('input[data-folder-name]'));expect(labelled(copy.uploadFile)).toBe(f.root.querySelector('input[type=file]'))
+  const input=f.root.querySelector<HTMLInputElement>('input[data-folder-name]')!;input.value='new';input.dispatchEvent(new Event('input',{bubbles:true}));await settle()
+  click(f.root,copy.create);await settle();expect(f.call).toHaveBeenCalledWith('nas.files.create',{grantId:id,relative:'',name:'new'})
+  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
+  Object.defineProperty(upload,'files',{value:[{name:'note.bin',size:3,arrayBuffer:async()=>new Uint8Array([0,1,255]).buffer}]})
+  upload.dispatchEvent(new Event('change',{bubbles:true}));await settle();click(f.root,copy.upload);await settle()
+  expect(f.call).toHaveBeenCalledWith('nas.files.write',{grantId:id,relative:'',name:'note.bin',data:'AAH/'})
+  click(f.root,copy.revoke);await settle();click(f.root,copy.confirmRevoke);await settle()
+  expect(f.root.textContent).toContain(copy.emptySelections)
+  expect(f.call.mock.calls.some(([m])=>/prepare|stream|publish|integration|root/.test(m))).toBe(false)
+ }finally{f.close()}
+})
+test('nine catalogs contain matching placeholders and distinct recovery copy for each safe failure',async()=>{
+ expect(Object.keys(m2Catalogs)).toHaveLength(9)
+ for(const [locale,copy]of Object.entries(m2Catalogs)){
+  expect(Object.keys(copy).sort()).toEqual(Object.keys(m2Catalogs.en).sort())
+  for(const key of Object.keys(copy)as Array<keyof typeof copy>){expect(copy[key].trim()).not.toBe('');expect(copy[key].match(/\{\w+\}/g)??[]).toEqual(m2Catalogs.en[key].match(/\{\w+\}/g)??[])}
+  const messages=['session_required','denied','not_found','conflict','commit-uncertain'].map(code=>m2ErrorCopy({code,message:'secret'},copy))
+  expect(new Set(messages).size).toBe(5)
+  const f=fixture(locale)
+  try{await settle();expect(f.root.textContent).toContain(copy.ownPermissions);f.fail('session_required');click(f.root,copy.refresh);await settle();expect(f.root.textContent).toContain(copy.errorSession);expect(f.root.textContent).not.toContain('Cookie=secret')}
+  finally{f.close()}
+ }
+})
+test('account change discards selections and pending dialogs until remount; two mounts isolate dialogs',async()=>{
+ const a=fixture(),b=fixture(),copy=m2Copy('en')
+ try{
+  await settle();click(a.root,copy.choose);click(b.root,copy.choose);await settle()
+  const ids=[...document.querySelectorAll('[id]')].map(n=>n.id).filter(Boolean);expect(new Set(ids).size).toBe(ids.length)
+  expect(a.root.querySelector('[role=dialog]')?.hasAttribute('aria-modal')).toBe(false)
+  a.setUser('normal2');a.reopen.forEach(fn=>fn());await settle()
+  expect(a.root.textContent).toContain(copy.accountChanged);expect(a.root.querySelector('[role=dialog]')).toBeNull()
+  expect(b.root.querySelector('[role=dialog]')).toBeTruthy()
+ }finally{a.close();b.close()}
+})
+
+test('read-only selection hides mutations; cancellation never confirms and errors never auto-retry',async()=>{
+ const f=fixture(),copy=m2Copy('en')
+ try{
+  await settle();click(f.root,copy.choose);await settle();click(f.root,'Select Home');click(f.root,copy.cancel);await settle()
+  expect(f.call.mock.calls.some(([m])=>m==='nas.grants.confirm')).toBe(false)
+  click(f.root,copy.choose);await settle();click(f.root,'Select Home');await settle();click(f.root,copy.confirm);await settle()
+  expect(f.call).toHaveBeenCalledWith('nas.grants.confirm',{folder:'/home',writable:false})
+  click(f.root,copy.openFiles);await settle()
+  expect(f.root.querySelector('input[type=file]')).toBeNull();expect(f.root.querySelector('input[data-folder-name]')).toBeNull()
+  f.fail('not_found');click(f.root,copy.inspect);await settle();expect(f.root.textContent).toContain(copy.errorNotFound)
+  expect(f.call.mock.calls.filter(([m])=>m==='nas.files.stat')).toHaveLength(1)
+ }finally{f.close()}
+})
+test('late discovery is discarded on unmount; a failed refresh does not forget the original account binding',async()=>{
+ const f=fixture(),copy=m2Copy('en')
+ try{
+  await settle()
+  const original=f.call.getMockImplementation()!
+  f.call.mockImplementation(async(method,args)=>{if(method==='app.status')throw {code:'session_required'};return original(method,args)})
+  f.reopen.forEach(fn=>fn());await settle()
+  f.call.mockImplementation(original);f.setUser('normal2');f.reopen.forEach(fn=>fn());await settle()
+  expect(f.root.textContent).toContain(copy.accountChanged)
+ }finally{f.close()}
+ const g=fixture()
+ await settle()
+ let release!:(value:unknown)=>void
+ const original=g.call.getMockImplementation()!
+ g.call.mockImplementation(async(method,args)=>method==='nas.discovery'?new Promise(r=>release=r):original(method,args))
+ click(g.root,copy.choose);await settle();g.app.unmount()
+ release({files:null,shares:[{name:'private',path:'/private',isdir:true}],total:1,offset:0});await settle()
+ expect(g.root.childElementCount).toBe(0);g.root.remove()
+})
+
+test('pending upload blocks competing folder controls and duplicate submission; uncertain outcome is actionable',async()=>{
+ const f=fixture(),copy=m2Copy('en')
+ try{
+  await settle();click(f.root,copy.choose);await settle();click(f.root,'Select Home');await settle()
+  const checkbox=f.root.querySelector<HTMLElement>('[role=checkbox]')!;checkbox.click()
+  click(f.root,copy.confirm);await settle();click(f.root,copy.openFiles);await settle()
+  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
+  Object.defineProperty(upload,'files',{value:[{name:'note.bin',size:3,arrayBuffer:async()=>new Uint8Array([0,1,255]).buffer}]})
+  upload.dispatchEvent(new Event('change',{bubbles:true}));await settle()
+  let reject!:(error:unknown)=>void
+  const original=f.call.getMockImplementation()!
+  f.call.mockImplementation(async(method,args)=>method==='nas.files.write'?new Promise((_resolve,r)=>reject=r):original(method,args))
+  click(f.root,copy.upload);click(f.root,copy.upload);await settle()
+  for(const button of [...f.root.querySelectorAll('button')].filter(b=>[copy.choose,copy.revoke,copy.refresh,copy.openFiles].includes(b.textContent?.trim()??'')))expect(button.disabled).toBe(true)
+  reject({code:'commit-uncertain'});await settle()
+  expect(f.root.textContent).toContain(copy.errorUncertain)
+  expect(f.call.mock.calls.filter(([m])=>m==='nas.files.write')).toHaveLength(1)
+  expect([...f.root.querySelectorAll('button')].find(b=>b.textContent?.trim()===copy.upload)?.disabled).toBe(true)
+ }finally{f.close()}
+})
+
+function mountPicker(consent?:string){
+ const provider={discovery:async()=>({entries:[],nextOffset:undefined})} as unknown as M2Provider
+ const root=document.createElement('div');document.body.append(root)
+ const app=createApp({render:()=>h(AppRoot,{},()=>h(M2PathPicker,{open:true,locale:'en',consent}))})
+ app.provide(M2ProviderKey,provider);app.config.idPrefix=`picker-${Math.random()}`;app.mount(root)
+ return {root,close(){app.unmount();root.remove()}}
+}
+test('the picker shows the caller-provided consent copy and keeps the M2 copy by default',async()=>{
+ const custom=mountPicker('Read once with your DSM login.');await settle()
+ expect(custom.root.textContent).toContain('Read once with your DSM login.');expect(custom.root.textContent).not.toContain(m2Copy('en').consent);custom.close()
+ const plain=mountPicker();await settle()
+ expect(plain.root.textContent).toContain(m2Copy('en').consent);plain.close()
+})
+
+async function openFiles(f:ReturnType<typeof fixture>,locale='en'){
+ const copy=m2Copy(locale)
+ await settle()
+ // In ko the navigation item shares the Choose button's label; the page button is the last match.
+ ;[...f.root.querySelectorAll('button')].filter(b=>b.textContent?.trim()===copy.choose).at(-1)!.click();await settle();click(f.root,format(copy.select,'Home'));await settle()
+ f.root.querySelector<HTMLElement>('[role=checkbox]')!.click()
+ click(f.root,copy.confirm);await settle();click(f.root,copy.openFiles);await settle()
+ return copy
+}
+// UI FilePicker "Choose files" per locale, written as escapes: template sources keep non-English text in catalogs only.
+const chooseFiles:Record<string,string>={en:'Choose files','zh-TW':'\u9078\u64c7\u6a94\u6848','zh-CN':'\u9009\u62e9\u6587\u4ef6',ja:'\u30d5\u30a1\u30a4\u30eb\u3092\u9078\u629e',ko:'\ud30c\uc77c \uc120\ud0dd',de:'Dateien ausw\u00e4hlen',fr:'Choisir des fichiers',es:'Elegir archivos',it:'Scegli file'}
+test.each(Object.keys(chooseFiles))('upload uses the compact UI FilePicker in %s',async locale=>{
+ const f=fixture(locale)
+ try{
+  const copy=await openFiles(f,locale)
+  expect(f.root.textContent).toContain(chooseFiles[locale])
+  expect(f.root.querySelectorAll('input[type=file]')).toHaveLength(1)
+  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
+  expect(upload.multiple).toBe(false)
+  expect(f.root.querySelector(`label[for="${upload.id}"]`)?.textContent).toContain(copy.uploadFile)
+ }finally{f.close()}
+})
+test('an oversize file is refused with the limit message and is never uploaded',async()=>{
+ const f=fixture(),copy=m2Copy('en')
+ try{
+  await openFiles(f)
+  const upload=f.root.querySelector<HTMLInputElement>('input[type=file]')!
+  Object.defineProperty(upload,'files',{value:[new File([new Uint8Array(M2_MAX_BYTES+1)],'big.bin')]})
+  upload.dispatchEvent(new Event('change',{bubbles:true}));await settle()
+  expect(f.root.textContent).toContain(m2ErrorCopy({code:'limit-exceeded'},copy))
+  expect([...f.root.querySelectorAll('button')].find(b=>b.textContent?.trim()===copy.upload)?.disabled).toBe(true)
+  expect(f.call.mock.calls.some(([m])=>m==='nas.files.write')).toBe(false)
+ }finally{f.close()}
+})
+test('a downloaded read result is a UI Link with the file name',async()=>{
+ const f=fixture(),copy=m2Copy('en')
+ try{
+  await openFiles(f);click(f.root,copy.read);await settle()
+  const link=f.root.querySelector<HTMLAnchorElement>('a[download]')!
+  expect(link.textContent).toContain(copy.download);expect(link.download).toBe('notes.txt');expect(link.getAttribute('href')).toMatch(/^blob:/)
+ }finally{f.close()}
+})

package/dist/templates/native-go-vue/frontend/test/nas-provider.test.ts

@@ -0,0 +1,81 @@
+import {expect, test} from 'vitest'
+import {createMockNasService} from '../src/nas/mock-provider'
+
+const signal = () => new AbortController().signal
+async function selection(provider: ReturnType<ReturnType<typeof createMockNasService>['connect']>) {
+ const context = await provider.begin('user-personal', signal())
+ const page = await provider.list(context.contextId, undefined, undefined, signal())
+ return {context, candidate: page.entries[0]!}
+}
+
+test('two ordinary subjects cannot exchange contexts, candidates, intents or personal grants', async () => {
+ const service = createMockNasService(), a = service.connect('normal1'), b = service.connect('normal2')
+ const picked = await selection(a)
+ await expect(b.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'denied'})
+ await expect(b.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'denied'})
+ const intent = await a.prepare(picked.candidate.nodeId, signal())
+ await expect(b.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'denied'})
+ const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
+ expect(await b.grants(signal())).toEqual([])
+ await expect(b.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
+ expect(grant.actions).toEqual(['nas.files.list','nas.files.stat','nas.files.read'])
+ expect(JSON.stringify(grant)).not.toMatch(/\/volume|uid|sessionRef/)
+})
+
+test('intent expires at 30 seconds; candidate expires at 60; cancel never creates a grant', async () => {
+ let now = 1000
+ const service = createMockNasService({now:() => now}), a = service.connect('normal1')
+ const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
+ now += 30_000
+ await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'expired'})
+ now += 30_000
+ await expect(a.prepare(picked.candidate.nodeId, signal())).rejects.toEqual({code:'expired'})
+ const next = await selection(a), cancelIntent = await a.prepare(next.candidate.nodeId, signal())
+ await a.cancel(next.context.contextId)
+ await expect(a.confirm(cancelIntent.intentId, cancelIntent.summaryDigest, signal())).rejects.toEqual({code:'canceled'})
+ expect(await a.grants(signal())).toEqual([])
+})
+
+test('summary mismatch, replay, abort, role and session changes refuse; reconfirm gets a new ID', async () => {
+ const service = createMockNasService(), admin = service.connect('admin'), a = service.connect('normal1')
+ await expect(a.begin('app-shared', signal())).rejects.toEqual({code:'denied'})
+ const picked = await selection(a), intent = await a.prepare(picked.candidate.nodeId, signal())
+ await expect(a.confirm(intent.intentId, '0'.repeat(64), signal())).rejects.toEqual({code:'stale'})
+ const grant = await a.confirm(intent.intentId, intent.summaryDigest, signal())
+ await expect(a.confirm(intent.intentId, intent.summaryDigest, signal())).rejects.toEqual({code:'replay'})
+ await a.revoke(grant.grantId, grant.revision, signal())
+ const second = await a.prepare(picked.candidate.nodeId, signal())
+ expect((await a.confirm(second.intentId, second.summaryDigest, signal())).grantId).not.toBe(grant.grantId)
+ const aborted = new AbortController(); aborted.abort()
+ await expect(a.begin('user-personal', aborted.signal)).rejects.toEqual({code:'canceled'})
+ const context = await admin.begin('app-shared', signal()), page = await admin.list(context.contextId, undefined, undefined, signal())
+ const shared = await admin.prepare(page.entries[0]!.nodeId, signal())
+ service.setAdmin('admin', false)
+ await expect(admin.confirm(shared.intentId, shared.summaryDigest, signal())).rejects.toEqual({code:'denied'})
+ service.invalidate('normal1')
+ await expect(a.list(picked.context.contextId, undefined, undefined, signal())).rejects.toEqual({code:'stale'})
+})
+
+test('shared grant discovery is visible without becoming revoke authority; R and Q stay separate', async () => {
+ const service = createMockNasService({drained:false}), admin = service.connect('admin'), a = service.connect('normal1')
+ const ctx = await admin.begin('app-shared', signal()), page = await admin.list(ctx.contextId, undefined, undefined, signal())
+ const intent = await admin.prepare(page.entries[0]!.nodeId, signal()), grant = await admin.confirm(intent.intentId, intent.summaryDigest, signal())
+ expect((await a.grants(signal()))[0]?.grantId).toBe(grant.grantId)
+ await expect(a.revoke(grant.grantId, grant.revision, signal())).rejects.toEqual({code:'denied'})
+ expect(await admin.revoke(grant.grantId, grant.revision, signal())).toMatchObject({revoked:true,drained:false})
+})
+
+test('pagination binds cursor to actor/context/node and revision CAS rejects stale revoke',async()=> {
+ const service=createMockNasService({pageSize:1}), a=service.connect('normal1'), b=service.connect('normal2')
+ const {context,candidate}=await selection(a)
+ const page=await a.list(context.contextId,undefined,undefined,signal())
+ expect(page.entries).toHaveLength(1);expect(page.nextCursor).toBeTruthy()
+ expect((await a.list(context.contextId,undefined,page.nextCursor,signal())).entries[0]!.displayName).toBe('Empty folder')
+ await expect(a.list(context.contextId,candidate.nodeId,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
+ await expect(b.list(context.contextId,undefined,page.nextCursor,signal())).rejects.toEqual({code:'denied'})
+ const intent=await a.prepare(candidate.nodeId,signal()), grant=await a.confirm(intent.intentId,intent.summaryDigest,signal())
+ await expect(a.revoke(grant.grantId,grant.revision+1,signal())).rejects.toEqual({code:'stale'})
+ service.newEpoch()
+ expect((await a.grants(signal()))[0]!.effectiveState).toBe('suspended')
+ await expect(a.prepare(candidate.nodeId,signal())).rejects.toEqual({code:'stale'})
+})

package/dist/templates/native-go-vue/frontend/test/nas-request.test.ts

@@ -0,0 +1,21 @@
+// @vitest-environment jsdom
+import {expect,test,vi} from 'vitest'
+import {createApp,defineComponent} from 'vue'
+import {useNasRequest} from '../src/nas/use-request'
+
+test('unresponsive discovery times out in five seconds, aborts, and ignores late metadata',async()=> {
+ vi.useFakeTimers()
+ let request!:ReturnType<typeof useNasRequest>
+ const root=document.createElement('div')
+ const app=createApp(defineComponent({setup(){request=useNasRequest();return ()=>null}}));app.mount(root)
+ try {
+  let resolve!:(s:string)=>void, signal!:AbortSignal
+  const pending=request.run(s=>{signal=s;return new Promise<string>(r=>resolve=r)})
+  await vi.advanceTimersByTimeAsync(5000)
+  expect(await pending).toBeUndefined()
+  expect(request.busy.value).toBe(false);expect(signal.aborted).toBe(true)
+  expect(request.error.value).toEqual({code:'timeout'})
+  resolve('late private metadata');await Promise.resolve()
+  expect(request.error.value).toEqual({code:'timeout'})
+ } finally {app.unmount();vi.useRealTimers()}
+})

package/dist/templates/native-go-vue/frontend/test/nas-ui.test.ts

@@ -0,0 +1,261 @@
+// @vitest-environment jsdom
+import {expect, test, vi} from 'vitest'
+import {nextTick} from 'vue'
+import {mount} from '../src/main'
+import {createMockNasService} from '../src/nas/mock-provider'
+import {catalogs, nasCopy, format, errorCopy} from '../src/nas/i18n'
+import type {NasProvider} from '../src/nas/provider'
+import type {Context} from '../src/context'
+
+async function settle() {for(let i=0;i<20;i++){await Promise.resolve();await nextTick()}await new Promise(r=>setTimeout(r,25))}
+function click(root:HTMLElement, text:string) {const b=[...root.querySelectorAll('button')].find(b=>b.textContent?.trim()===text || b.getAttribute('aria-label')===text);expect(b,text).toBeTruthy();b!.click()}
+function fixture(nas:NasProvider | undefined, user='normal1', locale='en') {
+ const root=document.createElement('div');document.body.append(root)
+ const reopen:Array<()=>void>=[]
+ const ctx={locale,reopen(fn:()=>void){reopen.push(fn)},call:vi.fn(async(method:string)=> {
+  if(method==='app.status') return {package:'SamePackage',version:'1',user,admin:user==='admin'}
+  if(method==='integration.status') return {state:'not-enabled',reason:'not-requested',packageRunning:'unknown',scheduler:'not-probed'}
+  throw {code:'unknown_method'}
+ })} as Context
+ const app=mount(root,ctx,{nasProvider:nas})
+ return {root,app,ctx,reopen}
+}
+function cleanup(...fixtures:ReturnType<typeof fixture>[]) {for(const f of fixtures){f.app.unmount();f.root.remove()}}
+
+test('managed account pilot stays visibly off with maintenance and approval restrictions',async()=> {
+ const f=fixture(createMockNasService().connect('admin'),'admin')
+ try {
+  await settle()
+  expect(f.root.textContent).toContain('Managed account pilot: off')
+  expect(f.root.textContent).toContain('Account changes or unverified identity revoke access')
+  expect(f.root.textContent).toContain('Enabling this pilot is unavailable in this build')
+  expect([...f.root.querySelectorAll('button')].some(b=>b.textContent?.includes('Enable managed'))).toBe(false)
+ } finally {cleanup(f)}
+})
+
+test('nine complete catalogs resolve DSM locale aliases with English fallback',()=> {
+ expect(Object.keys(catalogs)).toEqual(['en','zh-TW','zh-CN','ja','ko','de','fr','es','it'])
+ for(const catalog of Object.values(catalogs)) {
+  expect(Object.keys(catalog).sort()).toEqual(Object.keys(catalogs.en).sort())
+  expect(Object.values(catalog).every(s=>typeof s==='string' && s.trim().length>0)).toBe(true)
+  for(const key of Object.keys(catalogs.en) as Array<keyof typeof catalogs.en>) {
+   expect(catalog[key].match(/\{\w+\}/g) ?? []).toEqual(catalogs.en[key].match(/\{\w+\}/g) ?? [])
+  }
+ }
+ expect(nasCopy('cht')).toEqual(catalogs['zh-TW'])
+ expect(nasCopy('zh_CN')).toEqual(catalogs['zh-CN'])
+ expect(nasCopy('unknown')).toEqual(catalogs.en)
+})
+
+test('account changes discard the bound provider UI and its pending candidate context',async()=> {
+ const provider=createMockNasService().connect('normal1'), cancel=vi.spyOn(provider,'cancel'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  f.ctx.call=vi.fn(async(method:string)=>method==='app.status'?{package:'SamePackage',version:'1',user:'normal2',admin:false}:{state:'not-enabled',reason:'not-requested',packageRunning:'unknown',scheduler:'not-probed'})
+  f.reopen.forEach(fn=>fn());await settle()
+  expect(f.root.textContent).toContain('normal2')
+  expect(f.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(f.root.textContent).not.toContain('Choose my folder')
+  expect(cancel).toHaveBeenCalled()
+ } finally {cleanup(f)}
+})
+
+test('all nine locale UIs localize dialog controls and allow keyboard review without mouse-only actions',async()=> {
+ for(const locale of Object.keys(catalogs)) {
+  const copy=nasCopy(locale), f=fixture(createMockNasService().connect('normal1'),'normal1',locale)
+  try {
+   await settle();click(f.root,copy.choosePersonal);await settle()
+   const selected=[...f.root.querySelectorAll('button')].find(b=>b.getAttribute('aria-label')===format(copy.select,'Projects'))!
+   selected.focus();expect(document.activeElement).toBe(selected)
+   // Native Button remains a keyboard-activatable button (browser verifies Enter).
+   expect(selected.tagName).toBe('BUTTON');selected.click();await settle()
+   click(f.root,copy.review);await settle();expect(f.root.textContent).toContain(copy.persistent)
+   expect(f.root.querySelector(`button[aria-label="${copy.close}"]`)).toBeTruthy()
+   click(f.root,copy.cancel);await settle()
+  } finally {cleanup(f)}
+ }
+})
+
+test('home unavailable is recoverable and native diagnostics are never rendered',async()=> {
+ const provider=createMockNasService({homeAvailable:false}).connect('normal1'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  expect(f.root.textContent).toContain('Required native identity or permission proof is unavailable')
+  provider.begin=async()=>{throw {code:'unknown',message:'/volume1/private-secret stderr'}}
+  click(f.root,'Retry');await settle()
+  expect(f.root.textContent).toContain('The request failed')
+  expect(f.root.textContent).not.toMatch(/private-secret|stderr/)
+ } finally {cleanup(f)}
+})
+
+test('picker browse, separate selection/summary, cancel, empty and confirm use injected provider only',async()=> {
+ const service=createMockNasService(), provider=service.connect('normal1'), cancel=vi.spyOn(provider,'cancel'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  expect(f.root.textContent).toContain('Mock preview')
+  expect(f.root.querySelector('[role="dialog"]')).toBeTruthy()
+  click(f.root,'Select Projects');await settle()
+  expect(f.root.textContent).not.toContain('Persistent access')
+  click(f.root,'Review access');await settle()
+  expect(f.root.textContent).toContain('Persistent access')
+  click(f.root,'Cancel');await settle()
+  expect(cancel).toHaveBeenCalled()
+  expect(await provider.grants(new AbortController().signal)).toEqual([])
+  click(f.root,'Choose my folder');await settle();click(f.root,'Open Empty folder');await settle()
+  expect(f.root.textContent).toContain('This folder is empty')
+  click(f.root,'Back');await settle();click(f.root,'Select Projects');await settle();click(f.root,'Review access');await settle();click(f.root,'Confirm access');await settle()
+  expect(f.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(f.root.textContent).toContain('Active')
+ } finally {cleanup(f)}
+})
+
+test('two same-package apps retain local modality, unique ARIA IDs and cancellation isolation',async()=> {
+ const service=createMockNasService(), a=fixture(service.connect('normal1')), b=fixture(service.connect('normal2'))
+ const body=document.body.getAttribute('style')
+ try {
+  await settle();click(a.root,'Choose my folder');click(b.root,'Choose my folder');await settle()
+  const ids=[...document.querySelectorAll('[id]')].map(n=>n.id).filter(Boolean)
+  expect(new Set(ids).size).toBe(ids.length)
+  for(const f of [a,b]) {
+   const dialog=f.root.querySelector('[role="dialog"]')!
+   expect(dialog.hasAttribute('aria-modal')).toBe(false)
+   for(const name of ['aria-labelledby','aria-describedby']) expect(f.root.querySelector(`[id="${dialog.getAttribute(name)}"]`)).toBeTruthy()
+  }
+  expect(getComputedStyle(b.root).pointerEvents).not.toBe('none')
+  click(a.root,'Cancel');await settle()
+  expect(a.root.querySelector('[role="dialog"]')).toBeNull()
+  expect(b.root.querySelector('[role="dialog"]')).toBeTruthy()
+  expect(document.body.getAttribute('style')).toBe(body)
+ } finally {cleanup(a,b)}
+})
+
+test('intent expiry is actionable; revoked but not drained never claims transfers stopped',async()=> {
+ let now=1000
+ const service=createMockNasService({now:()=>now,drained:false}), provider=service.connect('normal1'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle();click(f.root,'Select Projects');await settle();click(f.root,'Review access');await settle()
+  now+=30_000;click(f.root,'Confirm access');await settle()
+  expect(f.root.textContent).toContain('expired')
+  expect(await provider.grants(new AbortController().signal)).toEqual([])
+  click(f.root,'Cancel');await settle();click(f.root,'Choose my folder');await settle();click(f.root,'Select Projects');await settle();click(f.root,'Review access');await settle();click(f.root,'Confirm access');await settle()
+  click(f.root,'Revoke');await settle()
+  expect(f.root.textContent).toContain('already sent or written')
+  click(f.root,'Confirm revoke');await settle()
+  expect(f.root.textContent).toContain('Revoked; stopping transfers')
+ } finally {cleanup(f)}
+})
+
+test('unmount aborts late browse and cancels its context without creating a grant',async()=> {
+ const provider=createMockNasService().connect('normal1'), base=provider.list.bind(provider)
+ let resolve!:()=>void, requestSignal!:AbortSignal
+ provider.list=async(...args)=>{requestSignal=args[3];await new Promise<void>(r=>resolve=r);return base(...args)}
+ const cancel=vi.spyOn(provider,'cancel'), f=fixture(provider)
+ await settle();click(f.root,'Choose my folder');await settle();f.app.unmount()
+ expect(requestSignal.aborted).toBe(true);expect(cancel).toHaveBeenCalled()
+ resolve();await settle();expect(f.root.childElementCount).toBe(0);f.root.remove()
+})
+
+test('late begin after close is canceled and rapid double review consumes one intent',async()=> {
+ const provider=createMockNasService().connect('normal1'), begin=provider.begin.bind(provider)
+ let release!:()=>void
+ provider.begin=async(kind,signal)=>{await new Promise<void>(r=>release=r);return begin(kind,new AbortController().signal)}
+ const cancel=vi.spyOn(provider,'cancel'), prepare=vi.spyOn(provider,'prepare'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle();click(f.root,'Cancel');await settle()
+  release();await settle();expect(cancel).toHaveBeenCalled();expect(f.root.querySelector('[role="dialog"]')).toBeNull()
+  provider.begin=begin
+  click(f.root,'Choose my folder');await settle();click(f.root,'Select Projects');await settle()
+  click(f.root,'Review access');click(f.root,'Review access');await settle()
+  expect(prepare).toHaveBeenCalledTimes(1)
+ } finally {cleanup(f)}
+})
+
+test('long folder names stay text, and revoked without Q uses pending cleanup copy',async()=> {
+ const name='<img src=x onerror=alert(1)> '+ '\u5e74\u5ea6\u5831\u544a'.repeat(20)
+ const provider=createMockNasService({personalFolders:[name]}).connect('normal1'), f=fixture(provider)
+ try {
+  await settle();click(f.root,'Choose my folder');await settle()
+  expect(f.root.textContent).toContain(name);expect(f.root.querySelector('img')).toBeNull()
+  click(f.root,'Cancel');await settle()
+  provider.settings=async()=>({canManageShared:false,items:[{grantId:'fixture',revision:2,scopeKind:'user-personal',displayName:name,targetKind:'directory',actions:['nas.files.read'],effectiveState:'revoked',createdAt:1000,canRevoke:true,cleanupRequired:true}]})
+  click(f.root,'Refresh access');await settle()
+  expect(f.root.textContent).toContain('Revoked; cleanup needs verification')
+  expect(f.root.textContent).toContain('Read files')
+  expect(f.root.textContent).not.toContain('List folders')
+ } finally {cleanup(f)}
+})
+
+
+test('S8 production defaults display unavailable for normal/admin even when lifecycle is ready',async()=> {
+ for(const user of ['normal1','admin']) for(const locale of Object.keys(catalogs)) {
+  const f=fixture(undefined,user,locale),copy=nasCopy(locale)
+  try {
+   f.ctx.call=vi.fn(async(method:string)=> {
+    if(method==='app.status') return {package:'SamePackage',version:'1',user,admin:user==='admin'}
+    if(method==='integration.status') return {state:'ready',packageRunning:'running',scheduler:'ready'}
+    if(method==='personal.list') return {items:[]}
+    throw {code:'unknown_method'}
+   })
+   f.reopen.forEach(fn=>fn());await settle()
+   expect(f.root.textContent).toContain(copy.unavailableMessage)
+   expect(f.root.textContent).toContain(copy.pilotUnavailable)
+   expect(f.root.textContent).toContain(copy.noUnlock)
+   expect(f.root.textContent).not.toContain(copy.choosePersonal)
+   expect(f.root.textContent).not.toContain(copy.chooseShared)
+   expect(f.root.textContent).not.toContain(copy.emptyGrant)
+   expect(f.ctx.call.mock.calls.some(([method])=>method.startsWith('nas.'))).toBe(false)
+  } finally {cleanup(f)}
+ }
+})
+
+test('S8 unavailable connected providers are ignored; only development mocks have a picker',async()=> {
+ const connected=createMockNasService().connect('normal1')
+ Object.defineProperty(connected,'mode',{value:'connected'})
+ const settings=vi.spyOn(connected,'settings'),f=fixture(connected)
+ try {
+  await settle()
+  expect(f.root.textContent).toContain(nasCopy('en').unavailableMessage)
+  expect(f.root.textContent).not.toContain('Choose my folder')
+  expect(settings).not.toHaveBeenCalled()
+ } finally {cleanup(f)}
+})
+
+
+test('S8 safe error codes distinguish missing proof, denial, missing method and app authentication',()=> {
+ for(const copy of Object.values(catalogs)) {
+  for(const [code,key] of [['unavailable','errorNativeProof'],['denied','errorDenied'],['unknown_method','errorUnknownMethod'],['unsupported','errorUnsupported'],['session_required','errorSession'],['auth_unavailable','errorAuthentication']] as const) {
+   expect(errorCopy({code,message:'/volume1/private cookie=sid'},copy)).toBe(copy[key])
+   expect(errorCopy({code,message:'/volume1/private cookie=sid'},copy)).not.toMatch(/volume1|cookie=sid/)
+  }
+  expect(new Set(['unavailable','denied','unknown_method','unsupported'].map(code=>errorCopy({code},copy))).size).toBe(4)
+ }
+})
+
+
+test('S8 app request failures use localized safe-code copy without native diagnostics',async()=> {
+ for(const code of ['denied','unknown_method','unavailable','unsupported','session_required','auth_unavailable']) {
+  const f=fixture(undefined,'normal1','cht')
+  try {
+   await settle()
+   f.ctx.call=vi.fn(async()=>{throw {code,message:'/volume1/private cookie=sid'}})
+   f.reopen.forEach(fn=>fn());await settle()
+   expect(f.root.querySelector('[role="alert"]')?.textContent).toBe(errorCopy({code},nasCopy('cht')))
+   expect(f.root.textContent).not.toMatch(/volume1|cookie=sid/)
+  } finally {cleanup(f)}
+ }
+})
+
+ test('S1R risk and reauthorization are disclosed in nine unavailable UIs without data actions',async()=> {
+  for(const locale of Object.keys(catalogs)) {
+   const copy=nasCopy(locale) as any, f=fixture(undefined,'normal1',locale)
+   try {
+    await settle()
+    for(const key of ['relaxedRisk','relaxedReauthorize','relaxedPermissions']) {
+     expect(copy[key],`${locale}:${key}`).toBeTypeOf('string')
+     expect(f.root.textContent).toContain(copy[key])
+    }
+    expect(f.root.textContent).not.toContain(copy.choosePersonal)
+    expect(f.ctx.call.mock.calls.some(([method])=>method.startsWith('nas.'))).toBe(false)
+   } finally {cleanup(f)}
+  }
+ })

package/dist/templates/native-go-vue/frontend/test/native-controls.test.ts

@@ -0,0 +1,27 @@
+import {readdirSync,readFileSync} from 'node:fs'
+import {join} from 'node:path'
+import {expect,test} from 'vitest'
+const root=join(__dirname,'../src')
+const sources=(dir:string):string[]=>readdirSync(dir,{withFileTypes:true}).flatMap(e=>e.isDirectory()?sources(join(dir,e.name)):e.name.endsWith('.vue')?[join(dir,e.name)]:[])
+const template=(file:string)=>readFileSync(file,'utf8').replace(/<script[\s\S]*?<\/script>/g,'').replace(/<style[\s\S]*?<\/style>/g,'')
+const uses=(file:string,tag:string)=>new RegExp(`<${tag}[\\s>/]`).test(template(file))
+// The template ships @synopackageland/ui controls only; a native form control
+// means a missing UI component, which is a UI gap to report, not to paper over.
+test.each(['select','option','textarea','label','input','a'])('no vue template renders a native <%s>',tag=>{
+ expect(sources(root).filter(file=>uses(file,tag))).toEqual([])
+})
+// Form direction and the control id come from the UI: `direction="auto"` stacks labels in a
+// narrow package window, and a control inside a FormItem binds its id/ARIA by itself.
+test('FormItem controls rely on the UI auto layout and id binding',()=>{
+ const items=sources(root).filter(file=>uses(file,'FormItem'))
+ expect(items.length).toBeGreaterThan(0)
+ expect(items.filter(file=>/direction="vertical"|field\.controlId|#default="\{field\}"/.test(template(file)))).toEqual([])
+})
+// UI built-in text follows the Provider locale (nine locales), so every app root sets it once and no
+// component repeats a per-control locale or download label.
+test('app roots set the UI locale once and components do not translate UI text themselves',()=>{
+ const roots=sources(root).filter(file=>uses(file,'AppRoot'))
+ expect(roots.length).toBeGreaterThan(0)
+ expect(roots.filter(file=>!uses(file,'ConfigProvider'))).toEqual([])
+ expect(sources(root).filter(file=>/download-label|external-label|<FilePicker[^>]*:locale=/.test(template(file)))).toEqual([])
+})