@etazio/agent-sdk 0.1.0

package/types/shared/schemas.d.ts

@@ -0,0 +1,251 @@
+import { z } from 'zod';
+export declare const emailSchema: z.ZodString;
+export declare const passwordSchema: z.ZodString;
+export declare const displayNameSchema: z.ZodString;
+export declare const registerSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    displayName: z.ZodString;
+}, z.core.$strip>;
+export type RegisterInput = z.infer<typeof registerSchema>;
+export declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export declare const magicLinkRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export declare const magicLinkConsumeSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const slugSchema: z.ZodString;
+export declare const createWorkspaceSchema: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CreateWorkspaceInput = z.infer<typeof createWorkspaceSchema>;
+export declare const updateWorkspaceSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    deskSelfClaim: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const assignableRoleSchema: z.ZodEnum<{
+    admin: "admin";
+    guest: "guest";
+    member: "member";
+}>;
+export declare const createInvitationSchema: z.ZodObject<{
+    email: z.ZodString;
+    role: z.ZodDefault<z.ZodEnum<{
+        admin: "admin";
+        guest: "guest";
+        member: "member";
+    }>>;
+}, z.core.$strip>;
+export type CreateInvitationInput = z.infer<typeof createInvitationSchema>;
+export declare const acceptInvitationSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const updateMemberRoleSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        admin: "admin";
+        guest: "guest";
+        member: "member";
+    }>;
+}, z.core.$strip>;
+export declare const transferOwnershipSchema: z.ZodObject<{
+    userId: z.ZodString;
+}, z.core.$strip>;
+export declare const objectIdSchema: z.ZodString;
+export declare const worldMoveSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    x: z.ZodNumber;
+    z: z.ZodNumber;
+    rotY: z.ZodNumber;
+    anim: z.ZodEnum<{
+        idle: "idle";
+        run: "run";
+        walk: "walk";
+    }>;
+    t: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const worldJoinSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    participantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const worldSitSchema: z.ZodObject<{
+    seatId: z.ZodString;
+}, z.core.$strip>;
+export declare const opIdSchema: z.ZodString;
+/** Hülle einer Editor-Operation; die Operation selbst wird gegen editorOpSchema aus @huddle/scene-schema geprüft. */
+export declare const applyOpEnvelopeSchema: z.ZodObject<{
+    baseVersion: z.ZodNumber;
+    opId: z.ZodString;
+    op: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const publishSchema: z.ZodObject<{
+    baseVersion: z.ZodOptional<z.ZodNumber>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const lockSchema: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const deskAssignmentSchema: z.ZodObject<{
+    userId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const deskIdSchema: z.ZodString;
+export declare const DESK_LIMITS: {
+    /** Gegenstände je Schreibtisch (Objektbudget, Roadmap §6) */
+    readonly maxItems: 12;
+    /** Versatz auf der Ankerebene in Metern (je Achse; `DESK_ANCHOR_MAX_OFFSET` in scene-schema) */
+    readonly maxOffset: 0.15;
+    /** Obergrenze für die lokale Position frei abgelegter Gegenstände (`anchor: 'surface'`, SPA-95) – die Tischplatte begrenzt enger */
+    readonly maxSurfaceOffset: 1.5;
+    readonly maxLabel: 40;
+};
+export declare const deskItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    asset: z.ZodString;
+    anchor: z.ZodString;
+    offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    rotationY: z.ZodDefault<z.ZodNumber>;
+    overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        color: z.ZodOptional<z.ZodString>;
+        roughness: z.ZodOptional<z.ZodNumber>;
+        metalness: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** Eingabe für PUT /office/desks/:deskId/customization – Anker, Assets und Budget prüft der Server gegen Katalog und Layout. */
+export declare const deskCustomizationInputSchema: z.ZodObject<{
+    label: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    items: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        asset: z.ZodString;
+        anchor: z.ZodString;
+        offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+        rotationY: z.ZodDefault<z.ZodNumber>;
+        overrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            color: z.ZodOptional<z.ZodString>;
+            roughness: z.ZodOptional<z.ZodNumber>;
+            metalness: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        color: z.ZodOptional<z.ZodString>;
+        roughness: z.ZodOptional<z.ZodNumber>;
+        metalness: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    chair: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        color: z.ZodOptional<z.ZodString>;
+        roughness: z.ZodOptional<z.ZodNumber>;
+        metalness: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type DeskCustomizationInput = z.output<typeof deskCustomizationInputSchema>;
+export declare const inventoryItemIdSchema: z.ZodString;
+export declare const zoneIdSchema: z.ZodString;
+export declare const meetingTokenSchema: z.ZodObject<{
+    target: z.ZodUnion<readonly [z.ZodLiteral<"office">, z.ZodString]>;
+}, z.core.$strip>;
+export declare const zoneAccessInputSchema: z.ZodObject<{
+    userIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const mediaStateSchema: z.ZodObject<{
+    mic: z.ZodBoolean;
+    cam: z.ZodBoolean;
+    screen: z.ZodBoolean;
+    presence: z.ZodDefault<z.ZodEnum<{
+        fokus: "fokus";
+        frei: "frei";
+        weg: "weg";
+    }>>;
+}, z.core.$strip>;
+export declare const zoneKnockSchema: z.ZodObject<{
+    zoneId: z.ZodString;
+}, z.core.$strip>;
+export declare const zoneAdmitSchema: z.ZodObject<{
+    zoneId: z.ZodString;
+    userId: z.ZodString;
+    allow: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Grenzen des Chats. Die Reaktions-Grenze steckt in `CHAT_GLYPH_LIMITS` (chat.ts) und zählt
+ * Graphem-Cluster – `length` hätte ZWJ-Sequenzen mit Skin-Tone fälschlich abgelehnt (SPA-117).
+ */
+export declare const CHAT_LIMITS: {
+    readonly maxText: 2000;
+    readonly pageSize: 50;
+};
+/** Konversations-Schlüssel: room:office, room:<zoneId>, dm:<userA>:<userB> (Nutzer-IDs aufsteigend sortiert) */
+export declare const convSchema: z.ZodString;
+export declare const sendMessageSchema: z.ZodObject<{
+    conv: z.ZodString;
+    text: z.ZodString;
+    parentId: z.ZodOptional<z.ZodString>;
+    alsoToChannel: z.ZodOptional<z.ZodBoolean>;
+    blocks: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"confirm">;
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        fields: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>;
+        actions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            style: z.ZodDefault<z.ZodEnum<{
+                danger: "danger";
+                primary: "primary";
+                secondary: "secondary";
+            }>>;
+        }, z.core.$strip>>;
+        expiresAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+export declare const reactionSchema: z.ZodObject<{
+    glyph: z.ZodString;
+}, z.core.$strip>;
+/** „Schreibt gerade“ (SPA-133) */
+export declare const chatTypingSchema: z.ZodObject<{
+    conv: z.ZodString;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    typing: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const readSchema: z.ZodObject<{
+    conv: z.ZodString;
+}, z.core.$strip>;
+export declare const messagesQuerySchema: z.ZodObject<{
+    conv: z.ZodString;
+    before: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+/** DM-Schlüssel für zwei Nutzer (Reihenfolge egal). */
+export declare function dmConv(a: string, b: string): string;
+export declare const OBJECT_LIMITS: {
+    /** Objektzustand als JSON, Bytes */
+    readonly maxStateBytes: 2048;
+    /** Zustandsänderungen je Teilnehmer und Sekunde */
+    readonly statePerSecond: 5;
+    /** Aktionen je Teilnehmer und Sekunde */
+    readonly actionsPerSecond: 3;
+    /** Reaktionen (Glyph über dem Kopf) je Sekunde */
+    readonly reactPerSecond: 1;
+};
+/** Objekt-ID: Layout-Platzierung oder persönlicher Gegenstand `<deskId>:<itemId>` (SPA-140) */
+export declare const worldObjectIdSchema: z.ZodString;
+export declare const objectStateSchema: z.ZodObject<{
+    placementId: z.ZodString;
+    state: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+}, z.core.$strip>;
+export declare const objectActionSchema: z.ZodObject<{
+    placementId: z.ZodString;
+    action: z.ZodString;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+}, z.core.$strip>;
+export declare const reactSchema: z.ZodObject<{
+    glyph: z.ZodString;
+}, z.core.$strip>;

package/types/shared/sso.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+/**
+ * Anmeldung je Workspace (SPA-94): Google ohne Einrichtung, eigene OIDC-Verbindung, „nur SSO“.
+ * Die Tabelle hier ist die gemeinsame Sprache von API und Web.
+ */
+export declare const LOGIN_METHODS: readonly ['password', 'magic', 'google', 'oidc'];
+export type LoginMethod = (typeof LOGIN_METHODS)[number];
+export declare const LOGIN_METHOD_LABELS: Record<LoginMethod, string>;
+/** Workspace-Adresse wie bei Gather: `<slug>-<id>`. Die ID allein bleibt gültig. */
+export declare function workspaceRef(w: {
+    id: string;
+    slug: string;
+}): string;
+/** `acme-gmbh-65f…` → `{ slug: 'acme-gmbh', id: '65f…' }`; reine ID → `slug: null`. */
+export declare function parseWorkspaceRef(ref: string): {
+    slug: string | null;
+    id: string;
+} | null;
+export declare const domainSchema: z.ZodString;
+/** Anbieter-Domains, die nie als Firmendomain nachgewiesen werden dürfen. */
+export declare const PUBLIC_MAIL_DOMAINS: readonly ['gmail.com', 'googlemail.com', 'outlook.com', 'hotmail.com', 'live.com', 'yahoo.com', 'icloud.com', 'me.com', 'gmx.de', 'gmx.net', 'web.de', 't-online.de', 'posteo.de', 'mailbox.org', 'proton.me', 'protonmail.com', 'aol.com'];
+export declare function emailDomain(email: string): string;
+/** Name und Präfix des DNS-TXT-Nachweises. */
+export declare const DOMAIN_TXT_PREFIX = "_etazio-verify";
+export declare const DOMAIN_TXT_VALUE_PREFIX = "etazio-verify=";
+export interface SsoDomainDto {
+    domain: string;
+    verified: boolean;
+    verifiedAt: string | null;
+    /** Eintrag, den der Admin anlegen muss */
+    txtName: string;
+    txtValue: string;
+}
+export interface WorkspaceAuthDto {
+    password: boolean;
+    magicLink: boolean;
+    google: {
+        enabled: boolean;
+        available: boolean;
+        allowedDomains: string[];
+    };
+    oidc: {
+        enabled: boolean;
+        configured: boolean;
+        issuer: string;
+        clientId: string;
+        /** Das Secret selbst verlässt den Server nie. */
+        hasClientSecret: boolean;
+        scopes: string[];
+        label: string;
+        lastTest: {
+            at: string;
+            ok: boolean;
+            message: string | null;
+        } | null;
+    };
+    /** Nachgewiesene Domains dürfen ohne Einladung beitreten */
+    autoJoin: boolean;
+    domains: SsoDomainDto[];
+}
+/** Öffentliche Sicht vor dem Login – nur, welche Wege es gibt. */
+export interface WorkspaceLoginInfoDto {
+    workspace: {
+        id: string;
+        name: string;
+        slug: string;
+        ref: string;
+    };
+    methods: {
+        password: boolean;
+        magicLink: boolean;
+        google: boolean;
+        oidc: {
+            label: string;
+        } | null;
+    };
+}
+export interface SsoDiscoverResultDto {
+    workspaces: WorkspaceLoginInfoDto[];
+}
+export declare const updateWorkspaceAuthSchema: z.ZodObject<{
+    password: z.ZodOptional<z.ZodBoolean>;
+    magicLink: z.ZodOptional<z.ZodBoolean>;
+    google: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    oidcEnabled: z.ZodOptional<z.ZodBoolean>;
+    autoJoin: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type UpdateWorkspaceAuthInput = z.infer<typeof updateWorkspaceAuthSchema>;
+export declare const oidcConnectionSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    clientId: z.ZodString;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    label: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type OidcConnectionInput = z.infer<typeof oidcConnectionSchema>;
+export declare const addDomainSchema: z.ZodObject<{
+    domain: z.ZodString;
+}, z.core.$strip>;
+export declare const ssoDiscoverSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+/** Fehlercodes, die der Callback als `?sso_error=` an die Web-App hängt. */
+export declare const SSO_ERRORS: {
+    readonly cancelled: 'Die Anmeldung wurde abgebrochen.';
+    readonly state: 'Die Anmeldung ist abgelaufen oder wurde in einem anderen Browser gestartet. Bitte erneut versuchen.';
+    readonly provider: 'Der Anmeldedienst hat die Anmeldung nicht bestätigt.';
+    readonly email_unverified: 'Der Anmeldedienst bestätigt die E-Mail-Adresse nicht.';
+    readonly account_exists: 'Zu dieser Adresse gibt es schon ein Konto. Melde dich damit an; danach lässt sich SSO verknüpfen.';
+    readonly domain: 'Deine Adresse gehört nicht zu den für diesen Workspace freigegebenen Domains.';
+    readonly not_member: 'Du bist kein Mitglied dieses Workspaces. Wenn du eingeladen wurdest, öffne den Link aus der Einladungsmail.';
+    readonly disabled: 'Diese Anmeldung ist für den Workspace nicht freigeschaltet.';
+    readonly unavailable: 'Die Anmeldung mit Google ist auf diesem Server nicht eingerichtet.';
+};
+export type SsoErrorCode = keyof typeof SSO_ERRORS;
+/** Antwortdetail, wenn ein Workspace die aktuelle Anmeldeart nicht zulässt. */
+export interface LoginMethodRequiredDetails {
+    reason: 'login_method';
+    workspaceRef: string;
+    allowed: LoginMethod[];
+}

package/types/shared/tv.d.ts

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import type { ObjectStateValue } from './events.js';
+/**
+ * Fernseher (Phase 7e): Kanalzustand eines TV-Objekts im vorhandenen `object:state` (flach, ≤ 2 KB, synchron,
+ * persistent). `auto` = Verhalten von Phase 5 (nächste Bildschirmfreigabe landet automatisch auf der Fläche).
+ * Wiedergabeposition zur Serverzeit t: `position + (playing ? (t − at) / 1000 : 0)`; `at`/`by` setzt der Server.
+ */
+export declare const TV_SOURCES: readonly ['auto', 'off', 'share', 'video', 'embed', 'channel', 'web'];
+export type TvSource = (typeof TV_SOURCES)[number];
+export declare const TV_CHANNELS: readonly ['clock', 'dashboard', 'slideshow'];
+export type TvChannel = (typeof TV_CHANNELS)[number];
+export interface TvState {
+    source: TvSource;
+    /** share: Identität des Teilenden (Pin – schlägt die Automatik) */
+    sharer?: string;
+    /** video/embed: https-URL (Videodatei/HLS bzw. YouTube/Vimeo); slideshow: Bild-URLs, durch Zeilenumbruch oder Leerzeichen getrennt */
+    url?: string;
+    /** Vom Client ermittelt (oEmbed) oder Dateiname */
+    title?: string;
+    playing?: boolean;
+    /** Sekunden zur Serverzeit `at` */
+    position?: number;
+    /** Serverzeit (ms), zu der `position`/`playing` gesetzt wurden */
+    at?: number;
+    /** Teilnehmer, der die Wiedergabe zuletzt gesteuert hat */
+    by?: string;
+    /** 0–1, gemeinsam für alle (der TV hat eine Lautstärke) */
+    volume?: number;
+    channel?: TvChannel;
+    /** Video in Schleife (Standardkanal aus dem Editor) */
+    loop?: boolean;
+    /**
+     * Phase 7f (`source: 'web'`): Id eines Web-Kanals; mehrere durch Komma rotieren mit `rotate`.
+     * Ohne `web` gilt `url` als Ad-hoc-Adresse (flüchtiges Profil, keine Anmeldung).
+     */
+    web?: string;
+    /** Rotation mehrerer Kanäle in Sekunden (synchron über `at`) */
+    rotate?: number;
+}
+export declare const TV_LIMITS: {
+    /** URL-Länge in Zeichen */
+    readonly maxUrl: 1024;
+    readonly maxTitle: 120;
+    /** Hosts, die als `embed` erlaubt sind */
+    readonly embedHosts: readonly ['youtube.com', 'www.youtube.com', 'm.youtube.com', 'youtu.be', 'vimeo.com', 'www.vimeo.com', 'player.vimeo.com'];
+    readonly defaultVolume: 0.8;
+    /** Hörweite des Fernsehers in Metern (wie SCREEN_RANGE der Bindung) */
+    readonly earshot: 6;
+    /** Diashow: Wechsel in Sekunden */
+    readonly slideSeconds: 8;
+    /** `web`: Länge der Kanalliste (Rotation) in Zeichen */
+    readonly maxWeb: 520;
+};
+/** Kleiner URL-Zerleger ohne DOM-`URL` (shared läuft ohne DOM-Typen); relative Pfade (`/smoke/clip.webm`) sind erlaubt. */
+export declare function parseUrl(u: string): {
+    protocol: string;
+    host: string;
+    path: string;
+    query: Record<string, string>;
+} | null;
+export declare const tvStateSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        auto: "auto";
+        channel: "channel";
+        embed: "embed";
+        off: "off";
+        share: "share";
+        video: "video";
+        web: "web";
+    }>;
+    sharer: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    playing: z.ZodOptional<z.ZodBoolean>;
+    position: z.ZodOptional<z.ZodNumber>;
+    at: z.ZodOptional<z.ZodNumber>;
+    by: z.ZodOptional<z.ZodString>;
+    volume: z.ZodOptional<z.ZodNumber>;
+    channel: z.ZodOptional<z.ZodEnum<{
+        clock: "clock";
+        dashboard: "dashboard";
+        slideshow: "slideshow";
+    }>>;
+    loop: z.ZodOptional<z.ZodBoolean>;
+    web: z.ZodOptional<z.ZodString>;
+    rotate: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type TvValidation = {
+    ok: true;
+    state: TvState;
+} | {
+    ok: false;
+    error: string;
+};
+/** Zustand prüfen (Client-Vorprüfung und Server). Liefert den bereinigten Zustand. */
+export declare function validateTvState(raw: unknown): TvValidation;
+/** Laufzeitzustand vor Editor-Standard (`placement.state`) vor Katalog (`auto`) – wie `lightOn()`. */
+export declare function tvStateOf(runtime: ObjectStateValue | undefined, editorDefault?: ObjectStateValue | null): TvState;
+/** Sollposition in Sekunden zur (Server-)Zeit `now`; mit `duration` in Schleife bzw. am Ende geklemmt. */
+export declare function tvPosition(s: TvState, now: number, duration?: number): number;
+export interface EmbedInfo {
+    provider: 'youtube' | 'vimeo';
+    id: string;
+    /** Vorschaubild (YouTube direkt; Vimeo per oEmbed vom Client) */
+    poster: string | null;
+    /** Einbettungs-URL für das Overlay */
+    embedUrl: string;
+}
+/** YouTube-/Vimeo-Adresse erkennen (watch, youtu.be, shorts, embed, vimeo.com/<id>) */
+export declare function embedInfo(url: string): EmbedInfo | null;
+/** Direkt abspielbare Videoadresse (Dateiendung oder HLS)? */
+export declare function isVideoUrl(url: string): boolean;
+export declare function isHlsUrl(url: string): boolean;
+/** Anzeigename eines Videos: Titel, sonst Dateiname ohne Endung */
+export declare function tvTitle(s: TvState): string;
+/** Bild-URLs einer Diashow (Zeilenumbruch, Leerzeichen oder Komma getrennt) */
+export declare function slideshowUrls(s: TvState): string[];
+/** Aktuelles Bild einer Diashow zur Serverzeit `now` (Wechsel alle `slideSeconds`, synchron über `at`) */
+export declare function slideshowIndex(s: TvState, now: number, count: number): number;
+/** Beschriftung für Tooltip/Hinweiszeile (Name des Teilenden setzt der Client ein) */
+export declare function tvLabel(s: TvState, sharerName?: string | null): string;

package/types/shared/view.d.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+/**
+ * Ansichts- und Steuerungseinstellungen je Nutzer (Navigation, 09/2026, `specs/navigation-analysis.md` §4).
+ * Gelten global in allen Workspaces (wie das Avatar-Profil). Die 3D-Szene ist die einzige Wahrheit;
+ * „2D“, „2.5D“ und „3D“ sind Kamera-Presets derselben Szene. `auto` koppelt die Neigung an den Zoom.
+ */
+export declare const VIEW_PRESETS: readonly ['auto', 'top', 'iso', 'third'];
+export type ViewPreset = (typeof VIEW_PRESETS)[number];
+/** Wirksame Kamerastufe (im Preset `auto` aus dem Abstand abgeleitet) */
+export type ViewStage = Exclude<ViewPreset, 'auto'>;
+export declare const CAMERA_FOLLOW: readonly ['follow', 'loose', 'free'];
+export declare const CAMERA_ROTATE: readonly ['auto', 'fixed', 'snap90', 'free'];
+export declare const WALL_MODES: readonly ['auto', 'cutaway', 'transparent', 'cap', 'never'];
+export declare const CEILING_MODES: readonly ['auto', 'show', 'hide'];
+export declare const CLICK_MOVE: readonly ['double', 'single', 'off'];
+export declare const KEY_AXES: readonly ['auto', 'camera', 'world'];
+export declare const RUN_MODES: readonly ['shift', 'toggle', 'always'];
+export declare const DETAIL_LEVELS: readonly ['auto', 'low', 'high'];
+export type CameraFollow = (typeof CAMERA_FOLLOW)[number];
+export type CameraRotate = (typeof CAMERA_ROTATE)[number];
+export type WallMode = (typeof WALL_MODES)[number];
+export type CeilingMode = (typeof CEILING_MODES)[number];
+export type ClickMove = (typeof CLICK_MOVE)[number];
+export type KeyAxes = (typeof KEY_AXES)[number];
+export type RunMode = (typeof RUN_MODES)[number];
+export type DetailLevel = (typeof DETAIL_LEVELS)[number];
+/** Zoombereiche (Kameraabstand in m) je Stufe; `auto` überspannt alles */
+export declare const ZOOM_RANGE: Record<ViewPreset, [number, number]>;
+/** Startabstand je Preset */
+export declare const ZOOM_DEFAULT: Record<ViewPreset, number>;
+export declare const viewSettingsSchema: z.ZodObject<{
+    preset: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        iso: "iso";
+        third: "third";
+        top: "top";
+    }>>;
+    zoom: z.ZodPrefault<z.ZodObject<{
+        auto: z.ZodDefault<z.ZodNumber>;
+        top: z.ZodDefault<z.ZodNumber>;
+        iso: z.ZodDefault<z.ZodNumber>;
+        third: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    follow: z.ZodDefault<z.ZodEnum<{
+        follow: "follow";
+        free: "free";
+        loose: "loose";
+    }>>;
+    smoothing: z.ZodDefault<z.ZodNumber>;
+    rotate: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        fixed: "fixed";
+        free: "free";
+        snap90: "snap90";
+    }>>;
+    walls: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        cap: "cap";
+        cutaway: "cutaway";
+        never: "never";
+        transparent: "transparent";
+    }>>;
+    ceiling: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        hide: "hide";
+        show: "show";
+    }>>;
+    clickMove: z.ZodDefault<z.ZodEnum<{
+        double: "double";
+        off: "off";
+        single: "single";
+    }>>;
+    keyAxes: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        camera: "camera";
+        world: "world";
+    }>>;
+    run: z.ZodDefault<z.ZodEnum<{
+        always: "always";
+        shift: "shift";
+        toggle: "toggle";
+    }>>;
+    detail: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        high: "high";
+        low: "low";
+    }>>;
+    outlines: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ViewSettings = z.output<typeof viewSettingsSchema>;
+export type ViewSettingsInput = z.input<typeof viewSettingsSchema>;
+export declare function defaultViewSettings(): ViewSettings;
+/** Stufe, die im Preset `auto` zu einem Kameraabstand gehört (Hysterese macht der Aufrufer) */
+export declare function stageForDistance(dist: number): ViewStage;
+/** Wirksame Stufe eines Presets bei gegebenem Abstand */
+export declare function effectiveStage(preset: ViewPreset, dist: number): ViewStage;
+/** Preset-abhängige Defaults für `auto`-Werte */
+export declare function resolveRotate(v: CameraRotate, stage: ViewStage): Exclude<CameraRotate, 'auto'>;
+export declare function resolveWalls(v: WallMode, stage: ViewStage): Exclude<WallMode, 'auto'>;
+export declare function resolveCeiling(v: CeilingMode, stage: ViewStage): Exclude<CeilingMode, 'auto'>;
+export declare function resolveKeyAxes(v: KeyAxes, stage: ViewStage): Exclude<KeyAxes, 'auto'>;
+export declare const VIEW_PRESET_LABELS: Record<ViewPreset, string>;
+export declare const VIEW_PRESET_HINTS: Record<ViewPreset, string>;