@synopackageland/cli 0.5.3 → 0.6.0

package/templates/native-go-vue/frontend/src/jobs/JobsPanel.vue

@@ -1,135 +0,0 @@
-<script setup lang="ts">
-import {computed,inject,onMounted,onBeforeUnmount,ref,watch} from 'vue'
-import {Button,Callout,Checkbox,SettingsSection} from '@synopackageland/ui'
-import {JobsProviderKey,type BackgroundSummary,type JobView} from './provider'
-import {unavailableJobsProvider} from './mock-provider'
-import {jobPage,consentSummary} from './validate'
-import {jobCopy} from './i18n'
-import InteractiveJobForm from './InteractiveJobForm.vue'
-import {useNasRequest} from '../nas/use-request'
-const props=defineProps<{locale:string;section?:'all'|'interactive'|'background'}>(),copy=computed(()=>jobCopy(props.locale))
-// One provider can have both modes; the shell shows them as separate pages
-// while the combined 'all' view stays the default for the standalone preview.
-const mode=computed(()=>props.section??'all')
-const showInteractive=computed(()=>mode.value!=='background'),showBackground=computed(()=>mode.value!=='interactive')
-const visibleJobs=computed(()=>mode.value==='all'?jobs.value:jobs.value.filter(job=>job.mode===(mode.value==='interactive'?'interactive':'background')))
-const provider=inject(JobsProviderKey,unavailableJobsProvider),request=useNasRequest(),{busy,error}=request
-let poll:ReturnType<typeof setTimeout>|undefined
-function clearPoll(){if(poll!==undefined)clearTimeout(poll);poll=undefined}
-function schedulePoll(){if(provider.mode==='connected'&&provider.readiness?.interactive==='ready'&&jobs.value.some(j=>['pending','running','draining','cancel-requested'].includes(j.state)))poll=setTimeout(()=>{poll=undefined;void load()},2500)}
-const invalidated=ref(false)
-const nextCursor=ref<string>()
-const jobs=ref<readonly JobView[]>([]),summary=ref<BackgroundSummary>(),agree=ref(false),uncertain=ref(false)
-watch(error,e=>{if(['denied','session_required','auth_unavailable'].includes((e as {code?:string})?.code??'')){invalidated.value=true;jobs.value=[];summary.value=undefined;agree.value=false}})
-async function load(cursor?:string){if(invalidated.value||busy.value)return;clearPoll();const result=await request.run(async signal=>jobPage(await provider.list(signal,cursor)));if(result){jobs.value=result.items;nextCursor.value=result.nextCursor;schedulePoll()}else if(error.value&&provider.readiness?.interactive!=='revalidating'){jobs.value=[];nextCursor.value=undefined}}
-async function refresh(){await load()}
-async function prepare(){agree.value=false;const result=await request.run(async signal=>consentSummary(await provider.prepare(signal)));if(result)summary.value=result}
-function discard(){request.cancel();summary.value=undefined;agree.value=false}
-async function confirm(){
- const exact=summary.value;if(!exact||!agree.value||uncertain.value)return
- if(Date.now()>=exact.intentExpiresAt){request.error.value={code:'expired'};return}
- // Any missing confirmation reply is uncertain, including AbortSignal/timeout.
- // Keep the original intent and never offer a second submission from this view.
- uncertain.value=true
- const ok=await request.run(async signal=>{await provider.confirm(exact,signal);return true})
- if(ok){summary.value=undefined;uncertain.value=false;await refresh()}
-}
-async function lookup(){const exact=summary.value;if(!exact)return
- const found=await request.run(signal=>provider.lookup(exact.intentId,signal))
- if(found){summary.value=undefined;uncertain.value=false;await refresh()}
-}
-async function stop(job:JobView){
- await request.run(async signal=>{
-  if(job.mode==='background'){
-   const d=job.delegation;if(!d)throw {code:'unavailable'}
-   await provider.revoke(d.id,d.revision,d.storeRevision,signal)
-  }else await provider.cancel(job.jobId,job.revision,signal)
- });await refresh()
-}
-async function resubmit(job:JobView){
- await request.run(signal=>provider.resubmit!(job.jobId,signal));await refresh()
-}
-async function lookupResubmission(job:JobView){
- await request.run(signal=>provider.lookupResubmission!(job.jobId,signal));await refresh()
-}
-function fenceCanceled(job:JobView){return job.mode==='interactive'&&job.state==='canceled'&&job.safeReason==='fenced'}
-function label(job:JobView){const c=copy.value
- return ({pending:c.pending,running:c.running,'cancel-requested':c.stopping,draining:c.stopping,succeeded:c.succeeded,failed:c.failed,canceled:c.canceled,interrupted:c.interrupted,'cleanup-required':c.cleanup})[job.state]??c.error
-}
-function time(value:number){try{return new Intl.DateTimeFormat(props.locale,{dateStyle:'medium',timeStyle:'short'}).format(value)}catch{return new Date(value).toISOString()}}
-onMounted(()=>{if(provider.mode!=='unavailable')void refresh()})
-onBeforeUnmount(()=>{clearPoll();request.cancel();provider.disconnect()})
-</script>
-<template>
- <SettingsSection :title="copy.title" :collapsible="false" :aria-busy="busy" class="jobs-panel">
-  <Callout v-if="provider.mode==='unavailable'" tone="info" :title="copy.unavailable" />
-  <Callout v-else-if="invalidated" tone="danger" :title="copy.accessLost" role="alert" />
-  <template v-else>
-   <p v-if="provider.mode==='mock'">{{ copy.mock }}</p>
-   <template v-if="showInteractive">
-   <Callout v-if="provider.readiness?.interactive==='revalidating'" tone="info" :title="copy.revalidating" role="status" aria-live="polite" />
-   <Callout v-if="provider.readiness?.interactive==='unavailable'" tone="info" :title="copy.interactiveUnavailable" />
-   <p>{{ copy.interactiveHelp }}</p>
-   </template>
-   <template v-if="showBackground">
-   <Callout v-if="provider.readiness?.background==='unavailable'" tone="info" :title="copy.backgroundUnavailable" />
-   <p v-else>{{ copy.backgroundHelp }}</p>
-   </template>
-   <Callout v-if="error && (error as {code?:string}).code!=='revalidating'" tone="danger" :title="copy.error" role="alert" />
-   <InteractiveJobForm v-if="showInteractive && provider.interactive" :provider="provider" :locale="locale" @submitted="refresh" />
-   <div class="integration-actions">
-    <Button v-if="showBackground && provider.readiness?.background!=='unavailable'" :disabled="busy||!!summary" @click="prepare">{{ copy.prepare }}</Button>
-    <Button variant="secondary" :disabled="busy" @click="refresh">{{ copy.refresh }}</Button>
-   </div>
-   <section v-if="showBackground && summary" :aria-label="copy.prepare" class="jobs-review">
-    <dl class="nas-summary">
-     <dt>{{ copy.app }}</dt><dd>{{ summary.app }}</dd>
-     <dt>{{ copy.worker }}</dt><dd>{{ summary.worker }}</dd>
-     <dt>{{ copy.scope }}</dt><dd>{{ summary.parent }}</dd>
-     <dt>{{ copy.actions }}</dt><dd>{{ summary.actions.join(', ') }}</dd>
-     <dt>{{ copy.steps }}</dt><dd>{{ summary.steps }}</dd>
-     <dt>{{ copy.starts }}</dt><dd>{{ time(summary.notBefore) }}</dd>
-     <dt>{{ copy.expires }}</dt><dd>{{ time(summary.expiresAt) }}</dd>
-    </dl>
-    <ol><li v-for="(step,index) in summary.inputSummary" :key="index">{{ step }}</li></ol>
-    <p>{{ copy.warning }}</p>
-    <template v-if="!uncertain">
-     <Checkbox v-model="agree" class="jobs-agree" :disabled="busy" :label="copy.agree" />
-     <div class="integration-actions"><Button :disabled="busy||!agree" @click="confirm">{{ copy.confirm }}</Button><Button variant="secondary" @click="discard">{{ copy.close }}</Button></div>
-    </template>
-    <template v-else><p role="status">{{ copy.uncertain }}</p><Button :disabled="busy" @click="lookup">{{ copy.lookup }}</Button></template>
-   </section>
-   <p v-if="!visibleJobs.length&&!busy&&!error">{{ copy.empty }}</p>
-   <ul class="nas-grants">
-    <li v-for="job in visibleJobs" :key="job.jobId">
-     <p role="status">{{ label(job) }}</p>
-     <progress v-if="job.totalUnits!==undefined&&job.totalUnits>0" :value="job.completedUnits" :max="job.totalUnits" :aria-label="label(job)" />
-     <p v-else>{{ copy.unknown }}</p>
-     <p v-if="job.delegation?.revoked">{{ copy.revoked }}</p><p v-if="job.drained">{{ copy.drained }}</p>
-     <p v-if="job.effectsUnknown">{{ copy.effects }}</p>
-     <template v-if="fenceCanceled(job)">
-      <p>{{ copy.fenceCanceled }}</p>
-      <template v-if="provider.resubmissionState?.(job.jobId)==='uncertain'">
-       <p role="status">{{ copy.resubmitUncertain }}</p>
-       <Button variant="secondary" :disabled="busy||provider.readiness?.interactive!=='ready'" @click="lookupResubmission(job)">{{ copy.resubmitLookup }}</Button>
-      </template>
-      <p v-else-if="provider.resubmissionState?.(job.jobId)==='submitted'" role="status">{{ copy.resubmitSubmitted }}</p>
-      <template v-else>
-       <p v-if="!provider.canResubmit?.(job.jobId)">{{ copy.resubmitUnavailable }}</p>
-       <Button variant="secondary" :disabled="busy||provider.readiness?.interactive!=='ready'||!provider.canResubmit?.(job.jobId)" @click="resubmit(job)">{{ copy.resubmit }}</Button>
-      </template>
-     </template>
-     <Button v-if="['pending','running','draining','cancel-requested'].includes(job.state)" variant="secondary" :disabled="busy||provider.readiness?.interactive==='revalidating'" @click="stop(job)">{{ job.mode==='background'?copy.revoke:copy.cancel }}</Button>
-    </li>
-   </ul>
-   <Button v-if="nextCursor" :disabled="busy" variant="secondary" @click="load(nextCursor)">{{ copy.next }}</Button>
-  </template>
- </SettingsSection>
-</template>
-<style scoped>
-.jobs-panel { max-inline-size: 70ch; overflow-wrap: anywhere; }
-.jobs-review { margin-block: var(--ui-space-4, 1rem); }
-.jobs-agree { margin-block: var(--ui-space-4, 1rem); }
-dd { overflow-wrap: anywhere; }
-progress { max-inline-size: 100%; accent-color: var(--ui-accent); }
-</style>

package/templates/native-go-vue/frontend/src/jobs/connected-provider.ts

@@ -1,179 +0,0 @@
-import {reactive,shallowRef} from 'vue'
-import type {Context} from '../context'
-import type {JobsProvider,JobsAdminProvider,JobPage,JobView,BackgroundSummary,InteractivePlan,PreparedInteractive,InteractiveWorker} from './provider'
-import {jobPage,adminPage,jobViews} from './validate'
-
-export const ATTACH_RENEW_MS=2000
-export const ATTACH_TTL_MS=6000
-const REQUEST_MS=3000
-const MAX_ATTACH=2
-const ref=(x:unknown):x is string=>typeof x==='string'&&/^[a-f0-9]{64}$/.test(x)
-const positive=(x:unknown):x is number=>Number.isSafeInteger(x)&&Number(x)>0
-const refused=(code='invalid-request'):never=>{throw {code}}
-const safeCodes=new Set(['invalid-request','incompatible','unsupported','replay','stale','expired','denied','unavailable','suspended','revoked','fenced','revalidating','busy','limit-exceeded','canceled','timeout','cleanup-required','session_required','auth_unavailable'])
-function safeError(e:unknown){const code=(e as {code?:string})?.code;return {code:code&&safeCodes.has(code)?code:'unavailable'}}
-export type {PreparedInteractive} from './provider'
-interface Lease {jobId:string;attachId:string;revision:number;deadline:number}
-interface WireJob extends Omit<JobView,'completedUnits'|'totalUnits'|'delegation'> {
- progress:{completedUnits:number;totalUnits?:number}
- delegation?:{id:string;revision:number;storeRevision:number;state:string}
-}
-function view(raw:WireJob):JobView{
- if(!raw||!ref(raw.jobId)||!raw.progress)refused()
- return jobViews([{jobId:raw.jobId,revision:raw.revision,mode:raw.mode,state:raw.state,drained:raw.drained,effectsUnknown:raw.effectsUnknown,completedUnits:raw.progress.completedUnits,...(raw.safeReason?{safeReason:raw.safeReason}:{}),...(raw.progress.totalUnits===undefined?{}:{totalUnits:raw.progress.totalUnits}),...(raw.delegation?{delegation:{id:raw.delegation.id,revision:raw.delegation.revision,storeRevision:raw.delegation.storeRevision,revoked:raw.delegation.state==='revoked'}}:{})}])[0]
-}
-function prepared(raw:PreparedInteractive):PreparedInteractive{
- if(!raw||!ref(raw.intentId)||!ref(raw.jobId)||!ref(raw.summaryDigest)||!positive(raw.expiresAt))refused()
- return {intentId:raw.intentId,jobId:raw.jobId,summaryDigest:raw.summaryDigest,expiresAt:raw.expiresAt}
-}
-function workerViews(raw:unknown):InteractiveWorker[]{
- if(raw===undefined)return [] // Older owners have no submission form.
- if(!Array.isArray(raw)||raw.length>16)return refused()
- const ids=new Set<string>()
- return raw.map(w=>{
-  if(!w||typeof w.id!=='string'||! /^[a-z][a-z0-9_]{0,31}$/.test(w.id)||ids.has(w.id)||!positive(w.revision)||!positive(w.maxBytes)||w.maxBytes>524288||!Array.isArray(w.actions)||!w.actions.length||w.actions.length>3||new Set(w.actions).size!==w.actions.length||w.actions.some((a:unknown)=>!['nas.files.list','nas.files.stat','nas.files.read'].includes(a as string)))refused()
-  ids.add(w.id);return {id:w.id,revision:w.revision,actions:[...w.actions],maxBytes:w.maxBytes}
- })
-}
-export function createConnectedJobsProvider(ctx:Pick<Context,'call'>){
- let disposed=false,timer:ReturnType<typeof setTimeout>|undefined
- const readiness=reactive<{interactive:'ready'|'revalidating'|'unavailable';background:'unavailable'}>({interactive:'unavailable',background:'unavailable'})
- const workers=shallowRef<readonly InteractiveWorker[]>([])
- // Local plans are display/retry input, never authority or persisted credentials.
- const preparedPlans=new Map<string,InteractivePlan>(),plans=new Map<string,InteractivePlan>()
- const resubmissions=new Map<string,{state:'preparing'|'uncertain'|'submitted';prepared?:PreparedInteractive}>()
- function retain<K,V>(map:Map<K,V>,key:K,value:V){if(map.size>=256&&!map.has(key))map.delete(map.keys().next().value!);map.set(key,value)}
- const life=new AbortController(),leases=new Map<string,Lease>(),known=new Map<string,JobView>()
- async function request<T>(method:string,args:Record<string,unknown>,signal:AbortSignal):Promise<T>{
-  if(disposed||signal.aborted)refused('canceled')
-  let cleanup=()=>{}
-  const abort=new Promise<never>((_,reject)=>{
-   const canceled=()=>reject({code:'canceled'})
-   const deadline=setTimeout(()=>reject({code:'timeout'}),REQUEST_MS)
-   signal.addEventListener('abort',canceled,{once:true});life.signal.addEventListener('abort',canceled,{once:true})
-   cleanup=()=>{clearTimeout(deadline);signal.removeEventListener('abort',canceled);life.signal.removeEventListener('abort',canceled)}
-  })
-  try{
-   const value=await Promise.race([ctx.call<T>(method,args),abort])
-   if(disposed||signal.aborted)refused('canceled')
-   return value
-  }catch(e){const error=safeError(e);if(error.code==='revalidating')readiness.interactive='revalidating';else if(readiness.interactive!=='revalidating')readiness.interactive='unavailable';throw error}finally{cleanup()}
- }
- function schedule(){if(!disposed&&leases.size&&timer===undefined)timer=setTimeout(()=>{timer=undefined;void renew()},ATTACH_RENEW_MS)}
- async function renew(){
-  for(const lease of [...leases.values()]){
-   if(disposed)break
-   if(performance.now()>=lease.deadline){leases.delete(lease.jobId);continue}
-   try{
-    await request('jobs.attach',{jobId:lease.jobId,attachId:lease.attachId},life.signal)
-    if(!disposed&&leases.get(lease.jobId)===lease)lease.deadline=performance.now()+ATTACH_TTL_MS
-   }catch(e){
-    if(['expired','stale','denied','fenced','revalidating','canceled','session_required','auth_unavailable'].includes(safeError(e).code))leases.delete(lease.jobId)
-    // Busy/network failure cannot extend the original client deadline. Root
-    // monotonic TTL is authoritative even while this tab's timer is suspended.
-   }
-  }
-  schedule()
- }
- function remember(job:JobView){
-  if(known.size>=256&&!known.has(job.jobId))known.clear()
-  known.set(job.jobId,job)
-  const lease=leases.get(job.jobId)
-  if(lease){lease.revision=job.revision;if(['succeeded','failed','canceled','interrupted','cleanup-required'].includes(job.state))leases.delete(job.jobId)}
- }
- function disconnect(){
-  if(disposed)return
-  disposed=true
-  readiness.interactive='unavailable'
-  if(timer!==undefined)clearTimeout(timer)
-  timer=undefined
-  window.removeEventListener('pagehide',disconnect)
-  life.abort()
-  for(const lease of leases.values()){
-   // Best effort only. ctx.call preserves native session/CSRF transport. We do
-   // not claim delivery or Q and never renew after pagehide/bfcache/unmount.
-   void ctx.call('jobs.cancel',{jobId:lease.jobId,revision:lease.revision}).catch(()=>{})
-  }
-  workers.value=[];leases.clear();known.clear();preparedPlans.clear();plans.clear();resubmissions.clear()
- }
- window.addEventListener('pagehide',disconnect)
- const provider:JobsProvider={
-  mode:'connected',readiness,
-  async list(signal,cursor){
-   const raw=await request<{revision:number;items:WireJob[];nextCursor?:string;availability?:string;workers?:unknown}>('jobs.status',cursor?{cursor}:{},signal)
-   if(!raw||!Array.isArray(raw.items)||raw.items.length>10)refused()
-   const page=jobPage({revision:raw.revision,items:raw.items.map(view),...(raw.nextCursor?{nextCursor:raw.nextCursor}:{})})
-   try{workers.value=raw.availability==='session-required'?workerViews(raw.workers):[]}
-   catch(e){workers.value=[];readiness.interactive='unavailable';throw e}
-   if(raw.availability==='session-required')readiness.interactive='ready'
-   else if(readiness.interactive!=='revalidating')readiness.interactive='unavailable'
-   page.items.forEach(remember);return page
-  },
-  async prepare(){return refused('unavailable')},
-  async confirm(_summary:BackgroundSummary){return refused('unavailable')},
-  async lookup(intentId,signal){if(!ref(intentId))refused();const job=view(await request<WireJob>('jobs.lookup',{intentId},signal));remember(job);return job},
-  async cancel(jobId,revision,signal){if(!ref(jobId)||!positive(revision))refused();await request('jobs.cancel',{jobId,revision},signal);leases.delete(jobId)},
-  async revoke(id,revision,storeRevision,signal){
-   const job=[...known.values()].find(j=>j.delegation?.id===id)
-   if(!job)return refused('stale')
-   const raw=await request<{revoked:boolean;drained:boolean}>('jobs.revoke',{jobId:job.jobId,revision:job.revision,delegationRevision:revision,storeRevision},signal)
-   if(typeof raw?.revoked!=='boolean'||typeof raw.drained!=='boolean')refused()
-   return {revoked:raw.revoked,drained:raw.drained}
-  },
-  canResubmit(jobId){const job=known.get(jobId);return !!job&&job.mode==='interactive'&&job.state==='canceled'&&job.safeReason==='fenced'&&plans.has(jobId)&&!resubmissions.has(jobId)},
-  resubmissionState(jobId){const state=resubmissions.get(jobId)?.state;return state==='preparing'?undefined:state},
-  async resubmit(jobId,signal){
-   if(!provider.canResubmit?.(jobId)||readiness.interactive!=='ready')return refused('unavailable')
-   const plan=plans.get(jobId)!
-   // Reserve locally before the first await, preventing simultaneous clicks.
-   retain(resubmissions,jobId,{state:'preparing'})
-   let value:PreparedInteractive
-   try{value=await connected.prepareInteractive(signal,plan.worker,plan.parent,plan.input)}
-   catch(e){resubmissions.delete(jobId);throw e}
-   plans.delete(jobId) // consume the old plan before the one submit attempt
-   resubmissions.set(jobId,{state:'uncertain',prepared:value})
-   const result=await connected.submitInteractive(value,signal)
-   resubmissions.set(jobId,{state:'submitted',prepared:value})
-   return result
-  },
-  async lookupResubmission(jobId,signal){
-   const retry=resubmissions.get(jobId)
-   if(!retry||retry.state!=='uncertain'||!retry.prepared)return refused('unavailable')
-   const job=await provider.lookup(retry.prepared.intentId,signal)
-   if(!job||job.jobId!==retry.prepared.jobId)return refused('unavailable')
-   retry.state='submitted';return {jobId:job.jobId}
-  },disconnect,
- }
- const connected=Object.assign(provider,{
-  readiness,
-  async prepareInteractive(signal:AbortSignal,worker:InteractivePlan['worker'],parent:InteractivePlan['parent'],input:InteractivePlan['input']){
-   const plan:InteractivePlan={worker:{id:worker.id,revision:worker.revision},parent:{id:parent.id,revision:parent.revision},input:{steps:input.steps.map(s=>({action:s.action,segments:[...s.segments],...(s.limit===undefined?{}:{limit:s.limit}),...(s.maxBytes===undefined?{}:{maxBytes:s.maxBytes})}))}}
-   const value=prepared(await request<PreparedInteractive>('jobs.prepare',plan as unknown as Record<string,unknown>,signal))
-   retain(preparedPlans,value.intentId,plan);return value
-  },
-  async submitInteractive(value:PreparedInteractive,signal:AbortSignal){
-   const input=prepared(value)
-   if(leases.size>=MAX_ATTACH)refused('busy')
-   const plan=preparedPlans.get(input.intentId);preparedPlans.delete(input.intentId)
-   // Never retry submit automatically, including after a lost response.
-   const raw=await request<Lease&{renewAfterMs:number;ttlMs:number}>('jobs.submit',{intentId:input.intentId,summaryDigest:input.summaryDigest},signal)
-   if(!raw||raw.jobId!==input.jobId||!ref(raw.attachId)||!positive(raw.revision)||raw.renewAfterMs!==ATTACH_RENEW_MS||raw.ttlMs!==ATTACH_TTL_MS)refused()
-   leases.set(raw.jobId,{jobId:raw.jobId,attachId:raw.attachId,revision:raw.revision,deadline:performance.now()+ATTACH_TTL_MS})
-   if(plan)retain(plans,raw.jobId,plan)
-   schedule()
-   return {jobId:raw.jobId}
-  },
- })
- return Object.assign(connected,{interactive:{get workers(){return workers.value},prepareInteractive:connected.prepareInteractive,submitInteractive:connected.submitInteractive}})
-}
-export function createConnectedJobsAdminProvider(ctx:Pick<Context,'call'>):JobsAdminProvider{
- return {mode:'connected',async list(signal,cursor){
-  if(signal.aborted)refused('canceled')
-  const page=adminPage(await ctx.call('jobs.admin.status',cursor?{cursor}:{}))
-  if(signal.aborted)refused('canceled');return page
- },async cancel(jobId,revision,signal){
-  if(signal.aborted)refused('canceled')
-  await ctx.call('jobs.admin.cancel',{jobId,revision})
-  if(signal.aborted)refused('canceled')
- }}
-}

package/templates/native-go-vue/frontend/src/jobs/i18n/de.json

@@ -1,62 +0,0 @@
-{
-  "title": "Aufträge",
-  "unavailable": "Aufträge sind in diesem Build nicht verfügbar.",
-  "mock": "Testvorschau: keine NAS-Aktion",
-  "interactiveHelp": "Diese Ansicht erneuert interaktive Aufträge alle 2 Sekunden. Nach 6 Sekunden ohne Erneuerung beginnt der Abbruch; er endet erst nach bestätigter Bereinigung. Schließen fordert den Abbruch an. Verborgene Tabs können zum Ablauf und Abbruch führen.",
-  "backgroundHelp": "Bestätigte Hintergrundarbeit kann nach Schließen oder Abmelden bis zum Ablauf oder Neustart weiterlaufen. Kein Fortsetzen nach Neustart.",
-  "prepare": "Hintergrundauftrag prüfen",
-  "confirm": "Einmal bestätigen",
-  "agree": "Ich stimme diesem einmaligen Nur-Lese-Auftrag auch während meiner Abwesenheit zu.",
-  "refresh": "Aktualisieren",
-  "lookup": "Ursprünglichen Auftrag prüfen",
-  "uncertain": "Bestätigungsantwort verloren. Ursprünglichen Auftrag prüfen, nicht erneut senden.",
-  "close": "Prüfung verwerfen",
-  "cancel": "Auftrag abbrechen",
-  "revoke": "Hintergrundzustimmung widerrufen",
-  "revoked": "Widerrufen",
-  "drained": "Bereinigung bestätigt",
-  "cleanup": "Bereinigung erforderlich",
-  "unknown": "Gesamtfortschritt unbekannt",
-  "error": "Anfrage fehlgeschlagen. Aktuellen Zustand durch Aktualisieren prüfen.",
-  "empty": "Keine Aufträge",
-  "pending": "Ausstehend",
-  "running": "Läuft",
-  "stopping": "Wird beendet",
-  "succeeded": "Abgeschlossen",
-  "failed": "Fehlgeschlagen",
-  "canceled": "Abgebrochen",
-  "interrupted": "Unterbrochen",
-  "app": "App",
-  "worker": "Worker",
-  "scope": "Bereichsreferenz",
-  "actions": "Aktionen",
-  "steps": "Schritte",
-  "expires": "Ablauf",
-  "starts": "Frühester Start",
-  "warning": "Bereits erfolgte Aktionen sind nicht rückgängig zu machen. Zustimmung gilt einmal im aktuellen Lauf.",
-  "effects": "Auswirkungen möglicherweise unbekannt",
-  "next": "Nächste Seite",
-  "accessLost": "Zugriff nicht bestätigt. Melden Sie sich erneut an und öffnen Sie diese Ansicht neu.",
-  "interactiveUnavailable": "Interaktive Aufträge sind erst nach Anbindung der nativen Sitzungs- und Berechtigungsprüfung verfügbar.",
-  "backgroundUnavailable": "Hintergrundaufträge sind nicht verfügbar.",
-  "adminTitle": "Auftragsverwaltung",
-  "loadManagement": "Aktualisieren, um den Verwaltungsstatus zu laden.",
-  "revalidating": "Die Paketprüfungen werden erneut validiert. Neue Aufträge sind pausiert. Aktualisieren Sie zur Prüfung der Wiederherstellung. Abgebrochene Aufträge werden nicht fortgesetzt.",
-  "fenceCanceled": "Dieser Auftrag wurde abgebrochen, weil die Paketprüfungen nicht verfügbar waren. Nach der Wiederherstellung erstellt erneutes Senden einen neuen Auftrag mit erneuter Berechtigungsprüfung. Es erfolgt kein automatisches Senden.",
-  "resubmit": "Erneut senden",
-  "resubmitUnavailable": "Der ursprüngliche Ablauf ist in dieser Ansicht nicht verfügbar. Wählen Sie die Eingaben erneut, um einen neuen Auftrag zu erstellen.",
-  "resubmitUncertain": "Die Antwort auf das erneute Senden fehlt. Prüfen Sie den neuen Auftrag und senden Sie nicht erneut.",
-  "resubmitLookup": "Neuen Auftrag prüfen",
-  "resubmitSubmitted": "Ein neuer Auftrag wurde gesendet. Der abgebrochene Auftrag bleibt gestoppt.",
-  "newInteractive": "Neuer interaktiver Auftrag",
-  "chooseSource": "Quelldatei oder Ordner wählen",
-  "sourceHelp": "Nur lesender Auftrag mit Ihrer aktuellen DSM-Sitzung. Die Dateiauswahl speichert die Zustimmung für den übergeordneten Ordner. Inhalte werden verworfen; nur Zähler werden gemeldet.",
-  "operation": "Aktion",
-  "statOperation": "Metadaten prüfen",
-  "listOperation": "Ordner auflisten",
-  "readOperation": "Datei lesen (Bytes zählen)",
-  "entryLimit": "Maximale Einträge (1–100)",
-  "byteLimit": "Maximale Bytes",
-  "submitInteractive": "Auftrag einmal senden",
-  "interactiveSubmitted": "Auftrag gesendet. Prüfen Sie unten den Fortschritt."
-}

package/templates/native-go-vue/frontend/src/jobs/i18n/en.json

@@ -1,62 +0,0 @@
-{
-  "title": "Jobs",
-  "unavailable": "Jobs are unavailable in this build.",
-  "mock": "Mock preview — no NAS operation",
-  "interactiveHelp": "This view renews interactive work every 2 seconds. After 6 seconds without renewal, cancellation starts; it completes only after cleanup is confirmed. Closing the view requests cancellation. Hidden tabs may expire and cancel the job.",
-  "backgroundHelp": "An explicitly confirmed background job may continue after closing or signing out, until expiry or restart. Restart does not resume it.",
-  "prepare": "Review background job",
-  "confirm": "Confirm once",
-  "agree": "I agree to this one-time read-only job continuing while I am offline.",
-  "refresh": "Refresh",
-  "lookup": "Check original job",
-  "uncertain": "Confirmation reply was lost. Check the original job; do not submit again.",
-  "close": "Discard review",
-  "cancel": "Cancel job",
-  "revoke": "Revoke background consent",
-  "revoked": "Revoked",
-  "drained": "Cleanup confirmed",
-  "cleanup": "Cleanup required",
-  "unknown": "Progress total unknown",
-  "error": "Request could not be completed. Refresh to check the current state.",
-  "empty": "No jobs",
-  "pending": "Pending",
-  "running": "Running",
-  "stopping": "Stopping",
-  "succeeded": "Completed",
-  "failed": "Failed",
-  "canceled": "Canceled",
-  "interrupted": "Interrupted",
-  "app": "App",
-  "worker": "Worker",
-  "scope": "Scope reference",
-  "actions": "Actions",
-  "steps": "Steps",
-  "expires": "Expires",
-  "starts": "Earliest start",
-  "warning": "Effects already completed cannot be undone. Consent is valid for one job before the app restarts.",
-  "effects": "Effects may be unknown",
-  "next": "Next page",
-  "accessLost": "Access could not be verified. Sign in again and reopen this view.",
-  "interactiveUnavailable": "Interactive jobs are unavailable until native session and permission checks are connected.",
-  "backgroundUnavailable": "Background jobs are unavailable.",
-  "adminTitle": "Job management",
-  "loadManagement": "Refresh to load management status.",
-  "revalidating": "Package checks are being revalidated. New jobs are paused. Refresh to check recovery; canceled jobs will not resume.",
-  "fenceCanceled": "This job was canceled because package checks became unavailable. After recovery, resubmit to create a new job and check permissions again. Nothing is resubmitted automatically.",
-  "resubmit": "Resubmit",
-  "resubmitUnavailable": "The original plan is unavailable in this view. Select the inputs again to create a new job.",
-  "resubmitUncertain": "The resubmission reply was lost. Check the new job; do not submit again.",
-  "resubmitLookup": "Check new job",
-  "resubmitSubmitted": "A new job was submitted. The canceled job remains stopped.",
-  "newInteractive": "New interactive job",
-  "chooseSource": "Choose source file or folder",
-  "sourceHelp": "Read-only job using your current DSM session. Selecting a file saves consent for its containing folder. File contents are discarded; jobs report counters only.",
-  "operation": "Operation",
-  "statOperation": "Inspect metadata",
-  "listOperation": "List folder",
-  "readOperation": "Read file (count bytes)",
-  "entryLimit": "Maximum entries (1–100)",
-  "byteLimit": "Maximum bytes",
-  "submitInteractive": "Submit job once",
-  "interactiveSubmitted": "Job submitted. Check progress below."
-}

package/templates/native-go-vue/frontend/src/jobs/i18n/es.json

@@ -1,62 +0,0 @@
-{
-  "title": "Trabajos",
-  "unavailable": "Los trabajos no están disponibles en esta versión.",
-  "mock": "Vista simulada: sin operaciones NAS",
-  "interactiveHelp": "Esta vista renueva las tareas interactivas cada 2 segundos. Tras 6 segundos sin renovación, empieza la cancelación; termina cuando se confirma la limpieza. Cerrar la vista solicita la cancelación. Las pestañas ocultas pueden provocar la caducidad y la cancelación.",
-  "backgroundHelp": "Un trabajo de fondo confirmado puede continuar tras cerrar o salir hasta caducar o reiniciar. No se reanuda tras reiniciar.",
-  "prepare": "Revisar trabajo de fondo",
-  "confirm": "Confirmar una vez",
-  "agree": "Acepto este trabajo único de solo lectura mientras estoy desconectado.",
-  "refresh": "Actualizar",
-  "lookup": "Consultar trabajo original",
-  "uncertain": "Se perdió la respuesta. Consulte el trabajo original sin enviarlo de nuevo.",
-  "close": "Descartar revisión",
-  "cancel": "Cancelar trabajo",
-  "revoke": "Revocar consentimiento",
-  "revoked": "Revocado",
-  "drained": "Limpieza confirmada",
-  "cleanup": "Limpieza necesaria",
-  "unknown": "Total desconocido",
-  "error": "No se pudo completar la solicitud. Actualice para comprobar el estado.",
-  "empty": "Sin trabajos",
-  "pending": "Pendiente",
-  "running": "En ejecución",
-  "stopping": "Deteniéndose",
-  "succeeded": "Completado",
-  "failed": "Fallido",
-  "canceled": "Cancelado",
-  "interrupted": "Interrumpido",
-  "app": "Aplicación",
-  "worker": "Worker",
-  "scope": "Referencia de alcance",
-  "actions": "Acciones",
-  "steps": "Pasos",
-  "expires": "Caducidad",
-  "starts": "Inicio más temprano",
-  "warning": "Los efectos ya producidos no se pueden deshacer. El consentimiento vale una vez en el período actual.",
-  "effects": "Puede haber efectos desconocidos",
-  "next": "Página siguiente",
-  "accessLost": "No se pudo verificar el acceso. Inicie sesión y abra esta vista de nuevo.",
-  "interactiveUnavailable": "Las tareas interactivas no están disponibles hasta conectar las comprobaciones nativas de sesión y permisos.",
-  "backgroundUnavailable": "Las tareas en segundo plano no están disponibles.",
-  "adminTitle": "Gestión de tareas",
-  "loadManagement": "Actualice para cargar el estado de gestión.",
-  "revalidating": "Se están revalidando las comprobaciones del paquete. Los trabajos nuevos están en pausa. Actualice para comprobar la recuperación; los trabajos cancelados no se reanudan.",
-  "fenceCanceled": "Este trabajo se canceló porque las comprobaciones del paquete no estaban disponibles. Tras la recuperación, reenviarlo crea un trabajo nuevo y vuelve a comprobar los permisos. No hay reenvío automático.",
-  "resubmit": "Volver a enviar",
-  "resubmitUnavailable": "El plan original no está disponible en esta vista. Seleccione de nuevo las entradas para crear un trabajo nuevo.",
-  "resubmitUncertain": "Se perdió la respuesta al reenvío. Compruebe el trabajo nuevo y no vuelva a enviarlo.",
-  "resubmitLookup": "Comprobar trabajo nuevo",
-  "resubmitSubmitted": "Se envió un trabajo nuevo. El trabajo cancelado sigue detenido.",
-  "newInteractive": "Nueva tarea interactiva",
-  "chooseSource": "Elegir archivo o carpeta de origen",
-  "sourceHelp": "Tarea de solo lectura con su sesión DSM actual. Elegir un archivo guarda el consentimiento para su carpeta. El contenido se descarta; solo se informan contadores.",
-  "operation": "Operación",
-  "statOperation": "Consultar metadatos",
-  "listOperation": "Listar carpeta",
-  "readOperation": "Leer archivo (contar bytes)",
-  "entryLimit": "Máximo de entradas (1–100)",
-  "byteLimit": "Máximo de bytes",
-  "submitInteractive": "Enviar tarea una vez",
-  "interactiveSubmitted": "Tarea enviada. Consulte el progreso abajo."
-}

package/templates/native-go-vue/frontend/src/jobs/i18n/fr.json

@@ -1,62 +0,0 @@
-{
-  "title": "Tâches",
-  "unavailable": "Les tâches ne sont pas disponibles dans cette version.",
-  "mock": "Aperçu simulé : aucune opération NAS",
-  "interactiveHelp": "Cette vue renouvelle les tâches interactives toutes les 2 secondes. Après 6 secondes sans renouvellement, leur annulation commence et se termine après confirmation du nettoyage. Fermer la vue demande une annulation. Un onglet masqué peut entraîner une expiration et une annulation.",
-  "backgroundHelp": "Une tâche de fond confirmée peut continuer après fermeture ou déconnexion jusqu’à expiration ou redémarrage. Aucun redémarrage de tâche automatique.",
-  "prepare": "Examiner la tâche de fond",
-  "confirm": "Confirmer une fois",
-  "agree": "J’accepte cette tâche unique en lecture seule pendant mon absence.",
-  "refresh": "Actualiser",
-  "lookup": "Vérifier la tâche initiale",
-  "uncertain": "Réponse perdue. Vérifiez la tâche initiale sans la soumettre à nouveau.",
-  "close": "Abandonner l’examen",
-  "cancel": "Annuler la tâche",
-  "revoke": "Révoquer le consentement",
-  "revoked": "Révoqué",
-  "drained": "Nettoyage confirmé",
-  "cleanup": "Nettoyage nécessaire",
-  "unknown": "Total inconnu",
-  "error": "Impossible de terminer la demande. Actualisez pour vérifier l’état.",
-  "empty": "Aucune tâche",
-  "pending": "En attente",
-  "running": "En cours",
-  "stopping": "Arrêt en cours",
-  "succeeded": "Terminé",
-  "failed": "Échec",
-  "canceled": "Annulé",
-  "interrupted": "Interrompu",
-  "app": "Application",
-  "worker": "Worker",
-  "scope": "Référence du périmètre",
-  "actions": "Actions",
-  "steps": "Étapes",
-  "expires": "Expiration",
-  "starts": "Début au plus tôt",
-  "warning": "Les effets déjà produits ne sont pas annulables. Le consentement ne vaut qu’une fois dans cette session de fonctionnement.",
-  "effects": "Effets potentiellement inconnus",
-  "next": "Page suivante",
-  "accessLost": "Accès non vérifié. Reconnectez-vous et rouvrez cette vue.",
-  "interactiveUnavailable": "Les tâches interactives attendent la connexion des contrôles natifs de session et de droits.",
-  "backgroundUnavailable": "Les tâches en arrière-plan sont indisponibles.",
-  "adminTitle": "Gestion des tâches",
-  "loadManagement": "Actualisez pour charger l’état de gestion.",
-  "revalidating": "Les vérifications du paquet sont en cours de revalidation. Les nouveaux travaux sont suspendus. Actualisez pour vérifier le rétablissement ; les travaux annulés ne reprennent pas.",
-  "fenceCanceled": "Ce travail a été annulé car les vérifications du paquet étaient indisponibles. Après rétablissement, une nouvelle soumission crée un nouveau travail et revérifie les permissions. Aucune soumission automatique.",
-  "resubmit": "Soumettre à nouveau",
-  "resubmitUnavailable": "Le plan initial est indisponible dans cette vue. Sélectionnez à nouveau les entrées pour créer un nouveau travail.",
-  "resubmitUncertain": "La réponse à la nouvelle soumission a été perdue. Vérifiez le nouveau travail sans le soumettre à nouveau.",
-  "resubmitLookup": "Vérifier le nouveau travail",
-  "resubmitSubmitted": "Un nouveau travail a été soumis. Le travail annulé reste arrêté.",
-  "newInteractive": "Nouvelle tâche interactive",
-  "chooseSource": "Choisir un fichier ou dossier source",
-  "sourceHelp": "Tâche en lecture seule avec votre session DSM actuelle. Choisir un fichier enregistre le consentement pour son dossier parent. Le contenu est supprimé ; seuls les compteurs sont rapportés.",
-  "operation": "Opération",
-  "statOperation": "Vérifier les métadonnées",
-  "listOperation": "Lister le dossier",
-  "readOperation": "Lire le fichier (compter les octets)",
-  "entryLimit": "Nombre maximal (1–100)",
-  "byteLimit": "Octets maximaux",
-  "submitInteractive": "Envoyer la tâche une fois",
-  "interactiveSubmitted": "Tâche envoyée. Consultez la progression ci-dessous."
-}