@swiss-ai-hub/web 0.318.0 → 0.320.0

package/README.md

@@ -155,8 +155,8 @@ The same single-instance requirement applies to **PrimeVue** (its theme system i
 > { "dependencies": { "vue-router": "4.6.4" } }
 > ```
 >
-> Verify with `pnpm why vue-router` (`@vueuse/router` must show `4.6.4`) and `pnpm build` (`nuxt generate` must succeed —
-> forcing a single `vue-router` major instead breaks `@nuxtjs/i18n`, which needs 5.x).
+> Verify with `pnpm why vue-router` (`@vueuse/router` must show `4.6.4`) and `pnpm build` (`nuxt generate` must succeed
+> — forcing a single `vue-router` major instead breaks `@nuxtjs/i18n`, which needs 5.x).
 
 ## Quick start
 

package/{pages/auth/login.vue → components/Auth/LoginPanel.vue}

@@ -21,36 +21,14 @@
         </a>
         <div class="flex flex-col gap-2 text-center">
           <h2 class="text-xl text-white">
-            {{ t('auth.login.welcome', { companyName }) }}
+            <slot name="heading" />
           </h2>
           <p class="text-surface-400">
-            {{ t('auth.login.pleaseLogin') }}
+            <slot name="message" />
           </p>
         </div>
         <div class="flex flex-col gap-3">
-          <ProgressSpinner
-            v-if="isLoading"
-            class="!h-8 !w-8"
-          />
-          <template v-else>
-            <Button
-              v-for="idp in authProviders ?? []"
-              :key="idp.alias"
-              :label="t('auth.login.loginWith', { provider: idp.display_name })"
-              :icon="`pi ${idp.icon}`"
-              icon-pos="right"
-              class="!bg-white !text-black"
-              @click="login(idp.alias || undefined)"
-            />
-            <Button
-              v-if="(authProviders?.length ?? 0) === 0"
-              :label="t('auth.login.title')"
-              icon="pi pi-sign-in"
-              icon-pos="right"
-              class="!bg-white !text-black"
-              @click="login()"
-            />
-          </template>
+          <slot />
         </div>
       </div>
       <a
@@ -68,13 +46,5 @@
 <script setup lang="ts">
 import logo from '@core/assets/images/logo.png'
 
-definePageMeta({
-  layout: 'anonymous',
-})
-
 const { t } = useI18n()
-const { login } = useAuth()
-const { authProviders, isLoading } = useAuthProviders()
-
-const companyName = 'bbv Software Services AG'
 </script>

package/components/FormKit/CronInput.vue

@@ -0,0 +1,208 @@
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="grid grid-cols-2 gap-3 sm:grid-cols-5">
+      <div
+        v-for="position in POSITIONS"
+        :key="position.key"
+      >
+        <label
+          :for="`cron-${position.key}`"
+          class="mb-1 block text-sm font-medium"
+        >
+          {{ t(`lib.cron.${position.key}.label`) }}
+        </label>
+        <InputText
+          :id="`cron-${position.key}`"
+          :model-value="schedule[position.key]"
+          :aria-label="t(`lib.cron.${position.key}.label`)"
+          :invalid="Boolean(errors[position.key])"
+          :aria-invalid="Boolean(errors[position.key])"
+          class="w-full font-mono"
+          @update:model-value="(value) => updatePosition(position.key, value ?? '')"
+        />
+        <small
+          v-if="errors[position.key]"
+          class="mt-1 block text-red-500"
+        >
+          {{ errors[position.key] }}
+        </small>
+        <small
+          v-else
+          class="mt-1 block text-surface-500"
+        >{{ position.range }}</small>
+      </div>
+    </div>
+
+    <div>
+      <label
+        for="cron-timezone"
+        class="mb-1 block text-sm font-medium"
+      >
+        {{ t('lib.cron.timezone.label') }}
+      </label>
+      <Select
+        v-model="timezone"
+        :aria-label="t('lib.cron.timezone.label')"
+        input-id="cron-timezone"
+        :options="timezoneOptions"
+        :placeholder="timezonePlaceholder ?? t('lib.cron.timezone.placeholder')"
+        :filter="filter"
+        class="w-full"
+      />
+      <small class="mt-1 block text-surface-500">{{ t('lib.cron.timezone.help') }}</small>
+    </div>
+
+    <small class="text-surface-500">
+      {{ t('lib.cron.expression') }} <code class="font-mono">{{ expression }}</code>
+    </small>
+  </div>
+</template>
+
+<script setup lang="ts">
+/**
+ * Editor for a backend `CronSchedule`: the five cron positions plus an IANA timezone.
+ *
+ * The emitted value is the schedule object in the backend's own field names, so it round-trips through
+ * `config_data` untouched — the scheduler reads those keys directly. Positions are kept separate rather than
+ * joined into one "0 12 * * *" string because that is how `CronSchedule` stores them, and flattening here would
+ * make every consumer parse it back apart.
+ *
+ * Deliberately has no presets and no plain-language summary — that is #1581, which extends this component rather
+ * than replacing it.
+ */
+
+import { createMessage } from '@formkit/core'
+
+import type { FormKitNode } from '@formkit/core'
+
+interface CronSchedule {
+  minute: string
+  hour: string
+  day_of_month: string
+  month: string
+  day_of_week: string
+  timezone: string
+}
+
+type CronPosition = Exclude<keyof CronSchedule, 'timezone'>
+
+interface CronInputProps {
+  context: {
+    node: FormKitNode
+    value?: CronSchedule | null
+    attrs: Record<string, unknown>
+    timezonePlaceholder?: string
+    filter?: boolean
+  }
+}
+
+const props = defineProps<CronInputProps>()
+const { t } = useI18n()
+
+const POSITIONS: { key: CronPosition, range: string, min: number, max: number }[] = [
+  { key: 'minute', range: '0-59', min: 0, max: 59 },
+  { key: 'hour', range: '0-23', min: 0, max: 23 },
+  { key: 'day_of_month', range: '1-31', min: 1, max: 31 },
+  { key: 'month', range: '1-12', min: 1, max: 12 },
+  { key: 'day_of_week', range: '0-6', min: 0, max: 6 },
+]
+
+// Deliberately permissive: croniter accepts names (MON-FRI, JAN), steps, lists and the day-of-week specials, and a
+// stricter pattern here would reject schedules the backend is happy to run. This catches the two things that are
+// wrong in every cron dialect — a blank position and a stray character — and leaves grammar to the server, which
+// now rejects a malformed cron on save rather than storing it.
+const ALLOWED_CHARACTERS = /^[0-9A-Za-z*,\-/?#]+$/
+
+// Blocking so the surrounding form cannot be submitted while a position is empty or malformed. Without it the only
+// feedback is a 400 from the save endpoint, and before that endpoint validated, a blank position was stored and
+// silently broke every run of the profile — not only its scheduled ones.
+const ERROR_MESSAGE_KEY = 'cronPositions'
+
+// Shown in the inputs the moment the field is enabled, never applied behind the user's back. `CronSchedule`
+// requires all five positions and has no defaults, so leaving them blank would save a schedule the scheduler then
+// skips with only a log line to say why. Hourly is the least surprising visible starting point — `* * * * *` would
+// commit an admin to a run every minute for merely ticking the enable box.
+const HOURLY: CronSchedule = {
+  minute: '0',
+  hour: '*',
+  day_of_month: '*',
+  month: '*',
+  day_of_week: '*',
+  timezone: resolveBrowserTimezone(),
+}
+
+const timezonePlaceholder = computed(() => props.context.timezonePlaceholder)
+const filter = computed(() => props.context.filter ?? true)
+
+const schedule = computed<CronSchedule>(() => props.context.value ?? HOURLY)
+
+const errors = computed<Partial<Record<CronPosition, string>>>(() =>
+  Object.fromEntries(
+    POSITIONS.map(position => [position.key, positionError(position)]).filter(([, message]) => message),
+  ),
+)
+
+const expression = computed(() =>
+  POSITIONS.map(position => schedule.value[position.key] || '?').join(' '),
+)
+
+const timezone = computed({
+  get: () => schedule.value.timezone,
+  set: (value: string) => emitValue({ ...schedule.value, timezone: value }),
+})
+
+const timezoneOptions = computed<string[]>(() => {
+  // Not every engine implements supportedValuesOf; without it the admin can still keep the resolved zone.
+  const supported = (Intl as { supportedValuesOf?: (key: string) => string[] }).supportedValuesOf
+  return supported ? supported('timeZone') : [schedule.value.timezone, 'UTC']
+})
+
+function resolveBrowserTimezone(): string {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'
+  }
+  catch {
+    return 'UTC'
+  }
+}
+
+function positionError(position: { key: CronPosition, min: number, max: number }): string | undefined {
+  const value = schedule.value[position.key]
+  if (!value) return t('lib.cron.errors.required')
+  if (!ALLOWED_CHARACTERS.test(value)) return t('lib.cron.errors.invalid')
+
+  // Only plain integers are range-checked. Anything with a step, range or name is left to the server, whose
+  // croniter knows the dialect far better than a regex here could.
+  const outOfRange = value
+    .split(',')
+    .some(term => /^\d+$/.test(term) && (Number(term) < position.min || Number(term) > position.max))
+
+  return outOfRange ? t('lib.cron.errors.range', { min: position.min, max: position.max }) : undefined
+}
+
+function updatePosition(position: CronPosition, value: string) {
+  emitValue({ ...schedule.value, [position]: value.trim() })
+}
+
+// Always emits every key: a partial schedule passes the generated submission schema (which cannot carry
+// CronSchedule's croniter and timezone validators) and is then rejected by the save endpoint.
+function emitValue(value: CronSchedule) {
+  props.context.node.input({ ...value })
+}
+
+watch(errors, (current) => {
+  props.context.node.store.remove(ERROR_MESSAGE_KEY)
+  const first = Object.values(current)[0]
+  if (!first) return
+
+  props.context.node.store.set(
+    createMessage({ blocking: true, key: ERROR_MESSAGE_KEY, type: 'error', value: first, visible: true }),
+  )
+}, { immediate: true })
+
+// Seed the stored value so enabling the field yields a complete, valid schedule even if the admin saves without
+// touching an input — what the inputs show and what gets saved must not diverge.
+onMounted(() => {
+  if (!props.context.value) emitValue(HOURLY)
+})
+</script>

package/components/FormKit/LocaleInput.vue

@@ -7,6 +7,7 @@
         :options="localeOptions"
         option-label="label"
         option-value="value"
+        :allow-empty="false"
         size="small"
       >
         <template #option="{ option }">
@@ -100,15 +101,24 @@ const localeOptions = locales.map(lang => ({
 
 const activeLocale = ref<Locale>('en')
 
+function isLocale(value: unknown): value is Locale {
+  return locales.includes(value as Locale)
+}
+
 // Get the current locale string value
 const localeValue = computed<LocaleStringDto>(() => {
   return props.context.value ?? { de: null, en: null, fr: null, it: null }
 })
 
 // Current input value for the active locale
+// The guard is belt-and-braces next to `:allow-empty="false"`: with an unset `activeLocale`
+// this setter used to write under the key `"null"`, producing a value whose four locales
+// were all empty but which no longer looked like a locale object to the backend's
+// normalization — so it slipped past validation and saved a blank name (issue #135).
 const currentValue = computed({
-  get: () => localeValue.value[activeLocale.value] ?? '',
+  get: () => (isLocale(activeLocale.value) ? localeValue.value[activeLocale.value] ?? '' : ''),
   set: (newVal: string) => {
+    if (!isLocale(activeLocale.value)) return
     const updated: LocaleStringDto = {
       ...localeValue.value,
       [activeLocale.value]: newVal || null,

package/components/Knowledge/Document/List.vue

@@ -140,7 +140,7 @@ const { tenantId } = useTenant()
 const { getDocumentSourceUrl } = useDocumentUrl()
 const { deleteDocument, isDeleting } = useDeleteDocument()
 const { deleteDocuments, isDeleting: isBatchDeleting } = useDeleteDocuments()
-const { isScheduled, schedule, unschedule } = useScheduledDeletions(
+const { isScheduled, scheduledAt, schedule, unschedule } = useScheduledDeletions(
   () => route.params.db as string,
   () => route.params.namespace as string,
 )
@@ -163,18 +163,24 @@ const checkedDocuments = ref<DocumentDto[]>([])
 
 const formatted = (datestr: string) => useDateFormat(new Date(datestr), 'DD.MM.YYYY')
 
-const isDocumentDeleting = (document: DocumentDto) => isScheduled(document.id) && document.is_ingested
+const isDocumentDeleting = (document: DocumentDto) => isScheduled(document.id)
 
-// Processing documents are mid-ingestion; removing their source now would race the pipeline.
-const isDocumentDeletable = (document: DocumentDto) => document.is_ingested && !isDocumentDeleting(document)
+// Deleting is safe at any stage of ingestion: the API only removes the source file, and the pipeline
+// drops the document's partition before the remove job touches any store, which aborts an in-flight
+// run before it writes. So the only reason to withhold the action is a deletion already in flight.
+const isDocumentDeletable = (document: DocumentDto) => !isDocumentDeleting(document)
 
-// Ids derive from the source URI, so re-uploading a just-deleted file reuses its id. When that id
-// reappears as a placeholder, the scheduled entry is stale and must be cleared.
+// Ids derive from the source URI, so re-uploading a just-deleted file reuses its id and would inherit
+// its "Deleting" badge. An upload rewrites the document, so an updated_at newer than the moment we
+// scheduled the deletion means this row is the replacement, not the one still on its way out.
 watch(
   () => props.documents,
   (documents) => {
     const reUploadedIds = (documents ?? [])
-      .filter(document => !document.is_ingested && isScheduled(document.id))
+      .filter((document) => {
+        const requestedAt = scheduledAt(document.id)
+        return requestedAt != null && new Date(document.updated_at).getTime() > requestedAt
+      })
       .map(document => document.id)
     if (reUploadedIds.length > 0) {
       unschedule(reUploadedIds)
@@ -200,15 +206,20 @@ const onSelectAllChange = ({ checked }: { checked: boolean }) => {
 
 const handleRowClick = (event: DataTableRowClickEvent) => {
   const document = event.data as DocumentDto
-  if (document.is_ingested && !isDocumentDeleting(document)) {
+  if (!isDocumentDeleting(document)) {
     emit('selected', document)
   }
 }
 
+// Only a deletion in flight makes a row inert. A document still being ingested stays dimmed but usable —
+// otherwise a failed ingestion leaves a row that can be neither opened nor removed.
 const getRowClass = (data: DocumentDto) => {
-  if (!data.is_ingested || isDocumentDeleting(data)) {
+  if (isDocumentDeleting(data)) {
     return 'opacity-50 cursor-not-allowed pointer-events-none'
   }
+  if (!data.is_ingested) {
+    return 'opacity-50'
+  }
   return data.id === route.params.document_id ? 'bg-surface-100 dark:bg-surface-800' : ''
 }
 

package/composables/app/useAppVersion.ts

@@ -3,18 +3,29 @@ import { minutesToMilliseconds } from 'date-fns'
 
 // Surfaces the running version of both services. The UI service version is baked
 // into the static bundle at build time (runtimeConfig.public.appVersion); the API
-// version is read from the health endpoint, which reports the channel tag (e.g.
-// `latest`) the running image was pulled as. When both match a single number is
+// version is read from the health endpoint. When both agree a single number is
 // shown, otherwise both are shown as `UI / API`.
 //
-// A release is promoted onto the `latest` channel by retagging the exact `-rc.N`
-// build that was tested, so the baked version keeps its release-candidate suffix
-// (e.g. `v0.317.0-rc.3`) even though the artifact IS the final release. Strip that
-// suffix only on the `latest` channel, so a promoted build shows its release
-// version (`v0.317.0`). On any other channel the build is genuinely a candidate or
-// rolling build, so keep the suffix to stay identifiable.
+// A release is promoted by retagging the exact `-rc.N` build that was tested, so
+// the baked UI version keeps its release-candidate suffix (e.g. `v0.317.0-rc.3`)
+// even though the artifact IS the final release. A container cannot read its own
+// image tag, so the release has to be inferred from what the API reports, and the
+// two deployment flavours report it differently: docker-compose pins the channel
+// tag (`latest`), while Helm pins an exact `vX.Y.Z` per instance and leaves the
+// API on its package metadata (`0.319.0`). Both are release signals; on either
+// one the suffix is dropped so a promoted build shows its release version.
+//
+// Versions are compared with the leading `v` normalised away, because one side is
+// a git tag (`v0.319.0`) and the other Python package metadata (`0.319.0`) — the
+// same version, and rendering it as `UI / API` would read as skew.
+//
+// Every other case is genuinely a candidate or a rolling build (another channel
+// such as `staging`, an API pinned to an explicit `-rc.N`, a nightly), so the
+// suffix stays to keep the build identifiable.
 const RELEASE_CHANNEL = 'latest'
-const toReleaseVersion = (version: string): string => version.replace(/-rc\.\d+$/, '')
+const RC_SUFFIX = /-rc\.\d+$/
+const toReleaseVersion = (version: string): string => version.replace(RC_SUFFIX, '')
+const toComparable = (version: string): string => version.replace(/^v/, '')
 
 export const useAppVersion = defineQuery(() => {
   const bakedUiVersion = useRuntimeConfig().public.appVersion as string
@@ -28,13 +39,21 @@ export const useAppVersion = defineQuery(() => {
     },
   })
 
+  // An API version that still carries `-rc.N` can never equal the stripped UI
+  // version, so a candidate deployment fails this check without a separate guard.
+  const isReleaseDeployment = computed(() => {
+    const api = apiVersion.value
+    if (!api) return false
+    return api === RELEASE_CHANNEL || toComparable(api) === toComparable(toReleaseVersion(bakedUiVersion))
+  })
+
   const uiVersion = computed(() =>
-    apiVersion.value === RELEASE_CHANNEL ? toReleaseVersion(bakedUiVersion) : bakedUiVersion,
+    isReleaseDeployment.value ? toReleaseVersion(bakedUiVersion) : bakedUiVersion,
   )
 
   const versionDisplay = computed(() => {
     const api = apiVersion.value
-    if (!api || api === uiVersion.value) return uiVersion.value
+    if (!api || toComparable(api) === toComparable(uiVersion.value)) return uiVersion.value
     return `${uiVersion.value} / ${api}`
   })
 

package/composables/document/useScheduledDeletions.ts

@@ -2,11 +2,15 @@ import { useStorage } from '@vueuse/core'
 
 import type { MaybeRefOrGetter } from 'vue'
 
-// Deletion is eventual (the pipeline cleans the stores minutes after the API returns 202), so the
-// list keeps returning a deleted document for a while. We persist scheduled ids in localStorage —
-// surviving page refreshes — to drive a "Deleting" badge, and expire them after a TTL so a failed
-// cleanup eventually re-surfaces the row instead of hiding it forever.
-const TTL_MS = 30 * 60 * 1000
+// Deletion is eventual (the pipeline cleans the stores well after the API returns), so the list keeps
+// returning a deleted document for a while. We persist scheduled ids in localStorage — surviving page
+// refreshes — to drive a "Deleting" badge, and expire them after a TTL so a failed cleanup eventually
+// re-surfaces the row instead of hiding it forever.
+//
+// The TTL has to cover a Dagster backlog, not just a slow run: the cleanup waits on a NATS sensor tick,
+// then the observe job's turn in the queue, then a run-status sensor tick, then the remove job's turn.
+// A busy instance can push that out for hours, so a day is the honest bound.
+const TTL_MS = 24 * 60 * 60 * 1000
 
 const store = useStorage<Record<string, number>>('aihub:scheduled-deletions', {})
 
@@ -15,9 +19,13 @@ function entryKey(database: string, namespace: string, documentId: string): stri
 }
 
 export function useScheduledDeletions(database: MaybeRefOrGetter<string>, namespace: MaybeRefOrGetter<string>) {
+  function scheduledAt(documentId: string): number | undefined {
+    const at = store.value[entryKey(toValue(database), toValue(namespace), documentId)]
+    return at != null && Date.now() - at < TTL_MS ? at : undefined
+  }
+
   function isScheduled(documentId: string): boolean {
-    const scheduledAt = store.value[entryKey(toValue(database), toValue(namespace), documentId)]
-    return scheduledAt != null && Date.now() - scheduledAt < TTL_MS
+    return scheduledAt(documentId) != null
   }
 
   function schedule(documentIds: string[]): void {
@@ -44,5 +52,5 @@ export function useScheduledDeletions(database: MaybeRefOrGetter<string>, namesp
     }
   }
 
-  return { isScheduled, schedule, unschedule }
+  return { isScheduled, scheduledAt, schedule, unschedule }
 }

package/formkit.config.ts

@@ -1,5 +1,6 @@
 import AgentSelector from '@core/components/FormKit/AgentSelector.vue'
 import ChipsInput from '@core/components/FormKit/ChipsInput.vue'
+import CronInput from '@core/components/FormKit/CronInput.vue'
 import IconSelector from '@core/components/FormKit/IconSelector.vue'
 import KnowledgeDatabaseSelector from '@core/components/FormKit/KnowledgeDatabaseSelector.vue'
 import LocaleInput from '@core/components/FormKit/LocaleInput.vue'
@@ -10,9 +11,66 @@ import { en, de, fr, it } from '@formkit/i18n'
 import { createInput } from '@formkit/vue'
 import { primeInputs } from '@sfxcode/formkit-primevue'
 
-import type { DefaultConfigOptions } from '@formkit/vue'
+import type { FormKitNode } from '@formkit/core'
+import type { DefaultConfigOptions, PluginConfigs } from '@formkit/vue'
+
+const LOCALES = ['de', 'en', 'fr', 'it'] as const
+
+// FormKit's built-in `required` rule only asks whether a value is present, and a localeInput's
+// value is always a `{de, en, fr, it}` object — non-empty, so `required` passes even when every
+// locale inside it is blank. Backend `LocaleInput` elements emit `localeRequired` instead
+// (see packages/core/swiss_ai_hub/core/form/elements/locale_input.py).
+function localeRequired(node: FormKitNode): boolean {
+  const value = node.value as Record<string, string | null> | null | undefined
+  if (!value) return false
+  return LOCALES.some(locale => !!value[locale]?.trim())
+}
+
+// FormKit skips a rule entirely when the node's value is empty, unless the rule opts out —
+// which is why the built-in `required` sets this too. Without it the rule would never run on a
+// never-touched field, whose value is still `null`, and a blank Name would pass on a fresh
+// create form: precisely the case this rule exists to catch.
+localeRequired.skipEmpty = false
+
+/**
+ * Passes when the value is listed in the sibling field named by `address`, or when that list is
+ * empty — backend allow-lists treat empty as unrestricted. Reading the sibling through `node.at()`
+ * registers it as a validation dependency, so FormKit re-runs this rule when the list itself
+ * changes, not only when this field does.
+ *
+ * Advisory only: it exists so an admin sees the conflict in the form. The backend never depends on
+ * it — a value outside the allow-list is rejected where it is actually used.
+ */
+const memberOf: PluginConfigs['rules'][string] = (node, address: string) => {
+  const allowed = node.at(address)?.value
+  if (!Array.isArray(allowed) || allowed.length === 0) return true
+  return allowed.includes(node.value)
+}
+
+const localeRequiredMessages = {
+  de: 'Mindestens eine Sprache muss ausgefüllt sein.',
+  en: 'At least one language must be filled in.',
+  fr: 'Au moins une langue doit être renseignée.',
+  it: 'Almeno una lingua deve essere compilata.',
+}
+
+const memberOfMessages = {
+  de: 'Dieser Wert steht nicht in der Liste der erlaubten Werte.',
+  en: 'This value is not in the allowed list.',
+  fr: 'Cette valeur ne figure pas dans la liste des valeurs autorisées.',
+  it: 'Questo valore non è presente nell\'elenco dei valori consentiti.',
+}
 
 const config: DefaultConfigOptions = {
+  rules: { localeRequired, memberOf },
+  messages: Object.fromEntries(
+    LOCALES.map(locale => [locale, {
+      validation: {
+        localeRequired: localeRequiredMessages[locale],
+        memberOf: memberOfMessages[locale],
+      },
+    }]),
+  ),
   inputs: {
     ...primeInputs,
     agentSelector: createInput(AgentSelector, {
@@ -21,6 +79,9 @@ const config: DefaultConfigOptions = {
     chipsInput: createInput(ChipsInput, {
       props: ['placeholder'],
     }),
+    cronInput: createInput(CronInput, {
+      props: ['timezonePlaceholder', 'filter'],
+    }),
     knowledgeDatabaseSelector: createInput(KnowledgeDatabaseSelector, {
       props: ['placeholder', 'filter'],
     }),

package/i18n/locales/de.yaml

@@ -557,7 +557,9 @@ auth:
     description: Bitte melden Sie sich an, um auf die Anwendung zuzugreifen
     tagline: Erleben Sie die Zukunft der künstlichen Intelligenz
     welcome: Willkommen im AI Hub von {companyName}
+    welcomeProvider: Willkommen im AI Hub — Anmeldung mit {provider}
     pleaseLogin: Bitte melden Sie sich an
+    pleaseLoginWith: Bitte melden Sie sich mit {provider} an
     loginWith: Anmelden mit {provider}
     customSolutions: Massgeschneiderte KI-Lösungen für Ihr Unternehmen
     logoAlt: Logo des Unternehmens
@@ -795,6 +797,28 @@ form:
       nicht wie erwartet. Um unerwartetes Verhalten zu vermeiden, deaktivieren Sie
       sie bitte vorübergehend, bis eine Korrektur veröffentlicht wird.
 lib:
+  cron:
+    errors:
+      required: Jede Position ist erforderlich — eine leere ergibt keinen gültigen
+        Zeitplan.
+      invalid: Hier sind nur Ziffern und die Zeichen * , - / ? erlaubt.
+      range: Werte müssen zwischen {min} und {max} liegen.
+    expression: 'Resultierender Cron-Ausdruck:'
+    minute:
+      label: Minute
+    hour:
+      label: Stunde
+    day_of_month:
+      label: Tag des Monats
+    month:
+      label: Monat
+    day_of_week:
+      label: Wochentag
+    timezone:
+      label: Zeitzone
+      placeholder: Zeitzone auswählen
+      help: Die Cron-Positionen werden in dieser Zeitzone interpretiert, damit ein
+        täglicher Zeitplan über Zeitumstellungen hinweg dieselbe Uhrzeit behält.
   vectorStore:
     label: Vektorspeicher
     help: Wissensdatenbank und Namensräume für die Suche auswählen

package/i18n/locales/en.yaml

@@ -548,7 +548,9 @@ auth:
     description: Please log in to access the application
     tagline: Experience the future of artificial intelligence
     welcome: Welcome to the AI Hub of {companyName}
+    welcomeProvider: Welcome to the AI Hub — sign in with {provider}
     pleaseLogin: Please log in
+    pleaseLoginWith: Please log in with {provider}
     loginWith: Login with {provider}
     customSolutions: Custom AI solutions for your company
     logoAlt: Logo of company
@@ -782,6 +784,27 @@ form:
     org_memory_performance: This feature may not work as expected in some cases. To
       avoid unexpected behavior, please temporarily disable it until a fix is released.
 lib:
+  cron:
+    errors:
+      required: Every position is required — a blank one is not a valid schedule.
+      invalid: Only digits and the characters * , - / ? are allowed here.
+      range: Values must be between {min} and {max}.
+    expression: 'Resulting cron expression:'
+    minute:
+      label: Minute
+    hour:
+      label: Hour
+    day_of_month:
+      label: Day of month
+    month:
+      label: Month
+    day_of_week:
+      label: Day of week
+    timezone:
+      label: Timezone
+      placeholder: Select a timezone
+      help: The cron positions are interpreted in this timezone, so a daily schedule
+        keeps the same wall-clock time across daylight-saving changes.
   vectorStore:
     label: Vector Store
     help: Select the knowledge database and namespaces to search