@asteby/metacore-runtime-react 23.9.3 → 23.10.0

package/src/license/license-gate.tsx

@@ -0,0 +1,277 @@
+/**
+ * <LicenseGate> — el primitivo del blindaje. Un host lo monta en UNA línea
+ * envolviendo su app autenticada:
+ *
+ *   <LicenseGate state={state} onActivate={activate}>
+ *     <AppShell />
+ *   </LicenseGate>
+ *
+ * Comportamiento según el estado (resuelto por el backend del host):
+ *   - Sin enforcement, o estado operable (valid/stale/grace) → renderiza children.
+ *     stale/grace además montan el <LicenseExpiryBanner> degradado por encima.
+ *   - enforcement && missing/invalid/expired → modal BLOQUEANTE full-screen,
+ *     no descartable, con el formulario de activación. Al activar con éxito el
+ *     host refresca el estado y el gate se abre sin recargar.
+ *
+ * Es branding-aware si el host pasa `branding` (logo/nombre desde el
+ * PlatformConfig del SDK); si no, cae a un encabezado neutro.
+ *
+ * INDEPENDIENTE del kernel: no importa su cliente ni fija su versión. Solo
+ * consume `LicenseState` y una promesa `onActivate`.
+ */
+import { useState, type ReactNode } from 'react'
+import { useTranslation } from 'react-i18next'
+import { ShieldAlert, Clock, Loader2 } from 'lucide-react'
+import { Button, Input } from '@asteby/metacore-ui'
+import {
+    isLicenseBlocking,
+    isTrialExpired,
+    type LicenseState,
+    type LicenseBranding,
+} from './types'
+import { LicenseStatusBadge } from './license-status-badge'
+import { LicenseExpiryBanner } from './license-expiry-banner'
+
+function cx(...parts: Array<string | false | undefined>): string {
+    return parts.filter(Boolean).join(' ')
+}
+
+export interface LicenseGateProps {
+    /** Estado actual, resuelto por el backend del host. `undefined` mientras
+     * carga → fail-open (renderiza children, nunca destella el candado). */
+    state: LicenseState | undefined
+    /** Activa una licencia con el código/token pegado. Resuelve → el host
+     * refresca `state` y el gate se abre. Rechaza con un Error cuyo `message`
+     * se muestra al usuario. */
+    onActivate: (code: string) => Promise<void>
+    children: ReactNode
+    /** Branding opcional (logo/nombre) para el encabezado del modal. */
+    branding?: LicenseBranding
+    /** Acción "Gestionar licencia" del banner degradado (opcional). */
+    onManage?: () => void
+    className?: string
+}
+
+export function LicenseGate({
+    state,
+    onActivate,
+    children,
+    branding,
+    onManage,
+    className,
+}: LicenseGateProps) {
+    const blocking = isLicenseBlocking(state)
+
+    return (
+        <>
+            {/* stale/grace/upcoming degradan con banner; el propio banner
+                decide si mostrarse. Bloqueado → no hace falta, el modal manda. */}
+            {!blocking && (
+                <LicenseExpiryBanner state={state} onManage={onManage} />
+            )}
+            {children}
+            {blocking && state && (
+                <LicenseGateModal
+                    state={state}
+                    onActivate={onActivate}
+                    branding={branding}
+                    className={className}
+                />
+            )}
+        </>
+    )
+}
+
+interface LicenseGateModalProps {
+    state: LicenseState
+    onActivate: (code: string) => Promise<void>
+    branding?: LicenseBranding
+    className?: string
+}
+
+function LicenseGateModal({
+    state,
+    onActivate,
+    branding,
+    className,
+}: LicenseGateModalProps) {
+    const { t } = useTranslation()
+    const [code, setCode] = useState('')
+    const [submitting, setSubmitting] = useState(false)
+    const [error, setError] = useState<string | null>(null)
+
+    const trialExpired = isTrialExpired(state)
+
+    const title = trialExpired
+        ? t('license.gate.trial_title', {
+              defaultValue: 'Tu prueba gratuita terminó',
+          })
+        : t('license.gate.title', { defaultValue: 'Activa tu licencia' })
+
+    const description = trialExpired
+        ? t('license.gate.trial_description', {
+              defaultValue:
+                  'Tu prueba gratuita terminó. Activa una licencia para continuar. Pega tu clave (lic_…) o el token firmado que te entregaron.',
+          })
+        : state.status === 'expired'
+          ? t('license.gate.expired_description', {
+                defaultValue:
+                    'Tu licencia venció y el periodo de gracia terminó. Activa una licencia vigente para seguir operando. Pega tu clave (lic_…) o el token firmado.',
+            })
+          : state.status === 'invalid'
+            ? t('license.gate.invalid_description', {
+                  defaultValue:
+                      'La licencia de esta instancia no es válida. Pega una clave (lic_…) o el token firmado que te entregó tu proveedor para reactivarla.',
+              })
+            : t('license.gate.missing_description', {
+                  defaultValue:
+                      'Esta instancia necesita una licencia activa para operar. Pega tu clave (lic_…) o el token firmado para activarla.',
+              })
+
+    const canSubmit = code.trim().length > 0 && !submitting
+
+    const submit = async () => {
+        if (!canSubmit) return
+        setSubmitting(true)
+        setError(null)
+        try {
+            await onActivate(code.trim())
+            // Éxito → el host refresca `state`; el gate se re-renderiza y este
+            // modal se desmonta solo. No recargamos.
+        } catch (e) {
+            const message =
+                e instanceof Error && e.message
+                    ? e.message
+                    : t('license.gate.activate_error', {
+                          defaultValue: 'No se pudo activar la licencia.',
+                      })
+            setError(message)
+            setSubmitting(false)
+        }
+    }
+
+    return (
+        <div
+            role="dialog"
+            aria-modal="true"
+            aria-labelledby="license-gate-title"
+            data-license-status={state.status}
+            className={cx(
+                'fixed inset-0 z-[100] flex items-center justify-center bg-background/90 p-4 backdrop-blur-sm',
+                className,
+            )}
+        >
+            <div className="w-full max-w-lg overflow-hidden rounded-2xl border bg-card text-card-foreground shadow-2xl">
+                <div className="flex flex-col gap-4 p-6">
+                    <div className="flex items-start gap-3">
+                        {branding?.logo ? (
+                            <img
+                                src={branding.logo}
+                                alt={branding.name ?? ''}
+                                className="h-10 w-10 shrink-0 rounded-xl object-contain"
+                            />
+                        ) : (
+                            <div
+                                className={cx(
+                                    'flex h-10 w-10 shrink-0 items-center justify-center rounded-xl',
+                                    trialExpired
+                                        ? 'bg-primary/10 text-primary'
+                                        : 'bg-destructive/10 text-destructive',
+                                )}
+                            >
+                                {trialExpired ? (
+                                    <Clock className="h-5 w-5" aria-hidden />
+                                ) : (
+                                    <ShieldAlert className="h-5 w-5" aria-hidden />
+                                )}
+                            </div>
+                        )}
+                        <div className="flex min-w-0 flex-col gap-1">
+                            <h2
+                                id="license-gate-title"
+                                className="text-lg leading-tight font-semibold"
+                            >
+                                {title}
+                            </h2>
+                            <div className="flex flex-wrap items-center gap-2">
+                                <LicenseStatusBadge status={state.status} />
+                                <span className="text-muted-foreground text-xs">
+                                    {branding?.name
+                                        ? branding.name
+                                        : t('license.gate.instance', {
+                                              defaultValue: 'Esta instancia',
+                                          })}
+                                </span>
+                            </div>
+                        </div>
+                    </div>
+
+                    <p className="text-muted-foreground text-sm">{description}</p>
+
+                    {state.reason && (
+                        <p className="bg-muted/50 text-muted-foreground rounded-md px-3 py-2 text-xs">
+                            {state.reason}
+                        </p>
+                    )}
+
+                    <form
+                        className="flex flex-col gap-2"
+                        onSubmit={(e) => {
+                            e.preventDefault()
+                            void submit()
+                        }}
+                    >
+                        <label
+                            htmlFor="license-gate-code"
+                            className="text-sm font-medium"
+                        >
+                            {t('license.gate.code_label', {
+                                defaultValue: 'Clave o token de licencia',
+                            })}
+                        </label>
+                        <Input
+                            id="license-gate-code"
+                            autoFocus
+                            autoComplete="off"
+                            spellCheck={false}
+                            placeholder={t('license.gate.code_placeholder', {
+                                defaultValue: 'lic_… o pega el token firmado',
+                            })}
+                            value={code}
+                            disabled={submitting}
+                            aria-invalid={error ? true : undefined}
+                            onChange={(e) => {
+                                setCode(e.target.value)
+                                if (error) setError(null)
+                            }}
+                        />
+                        {error && (
+                            <p role="alert" className="text-destructive text-sm">
+                                {error}
+                            </p>
+                        )}
+                        <Button
+                            type="submit"
+                            className="mt-1 w-full"
+                            disabled={!canSubmit}
+                        >
+                            {submitting && (
+                                <Loader2
+                                    className="h-4 w-4 animate-spin"
+                                    aria-hidden
+                                />
+                            )}
+                            {submitting
+                                ? t('license.gate.activating', {
+                                      defaultValue: 'Activando…',
+                                  })
+                                : t('license.gate.activate', {
+                                      defaultValue: 'Activar licencia',
+                                  })}
+                        </Button>
+                    </form>
+                </div>
+            </div>
+        </div>
+    )
+}

package/src/license/license-status-badge.tsx

@@ -0,0 +1,93 @@
+/**
+ * Insignia de estado de licencia — un chip que traduce el `LicenseStatus` a
+ * color + etiqueta legible. Reutilizable suelto (p. ej. en Ajustes de licencia)
+ * o embebido en el encabezado del <LicenseGate>.
+ */
+import { useTranslation } from 'react-i18next'
+import {
+    ShieldCheck,
+    ShieldAlert,
+    ShieldQuestion,
+    Clock,
+    CloudOff,
+} from 'lucide-react'
+import { Badge } from '@asteby/metacore-ui'
+import type { LicenseStatus } from './types'
+
+type BadgeVariant = 'default' | 'secondary' | 'destructive' | 'outline'
+
+interface StatusMeta {
+    variant: BadgeVariant
+    Icon: typeof ShieldCheck
+    key: string
+    defaultValue: string
+    /** Tinte amarillo para posturas degradadas (grace/stale) que `variant` no
+     * cubre — el sistema de badges no tiene "warning". */
+    warn?: boolean
+}
+
+const STATUS_META: Record<LicenseStatus, StatusMeta> = {
+    valid: {
+        variant: 'default',
+        Icon: ShieldCheck,
+        key: 'license.status.valid',
+        defaultValue: 'Activa',
+    },
+    stale: {
+        variant: 'outline',
+        Icon: CloudOff,
+        key: 'license.status.stale',
+        defaultValue: 'Sin verificar',
+        warn: true,
+    },
+    grace: {
+        variant: 'outline',
+        Icon: Clock,
+        key: 'license.status.grace',
+        defaultValue: 'En gracia',
+        warn: true,
+    },
+    expired: {
+        variant: 'destructive',
+        Icon: ShieldAlert,
+        key: 'license.status.expired',
+        defaultValue: 'Vencida',
+    },
+    missing: {
+        variant: 'secondary',
+        Icon: ShieldQuestion,
+        key: 'license.status.missing',
+        defaultValue: 'Sin licencia',
+    },
+    invalid: {
+        variant: 'destructive',
+        Icon: ShieldAlert,
+        key: 'license.status.invalid',
+        defaultValue: 'Inválida',
+    },
+}
+
+export interface LicenseStatusBadgeProps {
+    status: LicenseStatus
+    className?: string
+}
+
+export function LicenseStatusBadge({ status, className }: LicenseStatusBadgeProps) {
+    const { t } = useTranslation()
+    const meta = STATUS_META[status] ?? STATUS_META.missing
+    const { Icon } = meta
+
+    return (
+        <Badge
+            variant={meta.variant}
+            className={
+                (meta.warn
+                    ? 'border-amber-500/40 bg-amber-500/10 text-amber-700 dark:text-amber-400 '
+                    : '') + (className ?? '')
+            }
+        >
+            <Icon aria-hidden />
+            {t(meta.key, { defaultValue: meta.defaultValue })}
+        </Badge>
+    )
+}

package/src/license/types.ts

@@ -0,0 +1,90 @@
+/**
+ * Licencia de instancia — el contrato de estado que el backend del host (ops
+ * vía kernel `LicenseService`) expone y que este módulo pinta. El SDK NO habla
+ * con el kernel ni impone su versión: el host resuelve el `LicenseState` con su
+ * propio transporte y se lo pasa a <LicenseGate>. Así el gate es un primitivo
+ * reutilizable e INDEPENDIENTE del release del kernel.
+ *
+ * División de responsabilidades del blindaje:
+ *   - kernel  → enforcement (qué está permitido; firma/verifica el estado).
+ *   - SDK     → UX (este módulo: gate, banner, badge).
+ *   - hub     → emisión (mintea el token Ed25519).
+ *   - hosts   → wiring (resuelven el estado y montan <LicenseGate> en 1 línea).
+ */
+
+/** El estado operativo de la licencia, tal como lo deriva el backend. */
+export type LicenseStatus =
+    | 'valid'
+    | 'stale'
+    | 'grace'
+    | 'expired'
+    | 'missing'
+    | 'invalid'
+
+export interface LicenseState {
+    /** Licensing activo en esta instancia (LICENSING_ENFORCE). Si es false el
+     * gate es transparente: nunca bloquea ni degrada. */
+    enforced: boolean
+    configured: boolean
+    valid: boolean
+    status: LicenseStatus
+    reason?: string
+    org_id?: string
+    plan?: string
+    preset?: string
+    entitlements: string[]
+    wildcard: boolean
+    /** Lease: la instancia falló su check-in obligatorio con el hub. */
+    stale: boolean
+    max_offline_hours?: number
+    issued_at?: string
+    expires_at?: string
+    in_grace: boolean
+    grace_until?: string
+    days_remaining: number
+    last_checked_at?: string
+}
+
+/** La licencia es OPERABLE cuando permite operar (aunque sea degradada):
+ * valid, la postura `stale` del lease, o dentro de la ventana de gracia.
+ * missing/invalid/expired no son operables. Sin enforcement → siempre operable.
+ * Espeja `State.Operable()` del backend. */
+export function isLicenseOperable(state: LicenseState | undefined): boolean {
+    if (!state || !state.enforced) return true
+    return state.valid || state.in_grace
+}
+
+/** La instancia debe BLOQUEARSE tras el modal de activación cuando hay
+ * enforcement y la licencia es missing/invalid/expired (pasada la gracia).
+ * grace/stale degradan con banner en vez de bloquear. Espeja `State.Blocking()`.
+ * Mientras el estado aún carga (undefined) NO bloquea: fail-open en la UI para
+ * que un check lento/fallido nunca destelle un candado sobre la app. */
+export function isLicenseBlocking(state: LicenseState | undefined): boolean {
+    if (!state || !state.enforced) return false
+    return !isLicenseOperable(state)
+}
+
+/** Un preset/vertical está habilitado si la licencia otorga wildcard o lo lista
+ * explícitamente. Sin enforcement → todo habilitado. */
+export function isPresetEntitled(
+    state: LicenseState | undefined,
+    presetKey: string,
+): boolean {
+    if (!state || !state.enforced) return true
+    if (state.wildcard) return true
+    return state.entitlements?.includes(presetKey) ?? false
+}
+
+/** Marca trial vencido: el copy del gate cambia a "tu prueba terminó". */
+export function isTrialExpired(state: LicenseState | undefined): boolean {
+    return !!state && state.plan === 'trial' && state.status === 'expired'
+}
+
+/** Branding opcional para teñir el gate/banner. El host lo pasa desde su
+ * PlatformConfig del SDK (o cualquier fuente); sin él, fallback neutro. */
+export interface LicenseBranding {
+    /** Nombre de la plataforma/tenant, para el encabezado del gate. */
+    name?: string
+    /** URL del logo (se embebe como <img>). */
+    logo?: string
+}

package/src/types.ts

@@ -554,6 +554,13 @@ export interface PaginationMeta {
 // ActionMetadata re-exported from the sdk's action-registry. We mirror the
 // subset needed for the dispatcher so consumers of runtime-react don't have to
 // import the sdk directly for prop typings.
+/** One page of a multi-step (wizard) action. Mirrors the sdk's ActionStep. */
+export interface ActionStep {
+    title: string
+    description?: string
+    fields: ActionFieldDef[]
+}
+
 export interface ActionMetadata {
     key: string
     label: string
@@ -562,6 +569,8 @@ export interface ActionMetadata {
     confirm?: boolean
     confirmMessage?: string
     fields?: ActionFieldDef[]
+    /** Multi-step wizard form; when present the dispatcher renders a wizard. */
+    steps?: ActionStep[]
     requiresState?: string[]
     executable?: boolean
     placement?: 'row' | 'table' | 'create'

package/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for describing the origin of the Work and
-      reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Asteby, Inc.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.