@hasna/hooks 0.7.10 → 0.9.0

package/dist/lib/app-home.d.ts

@@ -11,6 +11,15 @@
  * physically migrated there, so a live store at the legacy home never becomes
  * invisible on upgrade.
  */
+export type PathKind = "config" | "data" | "state" | "cache";
+export interface PathsResolverOptions {
+    app: string;
+    internal?: boolean;
+    platform?: string;
+    home?: string;
+    env?: Record<string, string | undefined>;
+}
+export declare function dataDir(options: PathsResolverOptions): string;
 /** Resolve the user's home directory: $HOME, then $USERPROFILE, then the OS user database. */
 export declare function getHomeDir(env?: NodeJS.ProcessEnv): string;
 /**

package/dist/lib/installer.d.ts

@@ -9,7 +9,8 @@
  * Hooks run directly from the globally installed @hasna/hooks package.
  * No files are copied. The settings entry points to `hooks run <name>`.
  */
-import { type HookEvent } from "./registry.js";
+import { type HookEvent, type HookMeta } from "./registry.js";
+import { type StaleRegistration } from "./registration.js";
 export type Scope = "global" | "project";
 export type Target = "claude" | "gemini" | "codewith" | "all";
 type SingleTarget = Exclude<Target, "all">;
@@ -47,6 +48,18 @@ export declare function hookExists(name: string): boolean;
 /** Whether a hook's event can be registered for the given target */
 export declare function isEventSupported(internalEvent: HookEvent, target: SingleTarget): boolean;
 export declare function buildCodewithTomlFragment(name: string, profile?: string): string;
+/**
+ * The one conflict class that BLOCKS an install: two PreToolUse hooks on
+ * overlapping matchers that both rewrite the tool input
+ * (`hookSpecificOutput.updatedInput`). The harness keeps ONE rewrite per tool
+ * call — last writer wins — so whichever guard loses is silently disarmed
+ * with no error anywhere. `trash-guard` is the first such hook.
+ *
+ * Every other conflict stays advisory: it still installs, with the warning.
+ */
+export declare function detectRewriteConflict(name: string, scope: Scope, target: SingleTarget, 
+/** Injected for tests: the rewrite claim is a registry concern, the overlap is not. */
+lookup?: (hookName: string) => HookMeta | undefined): string | undefined;
 export declare function installHook(name: string, options?: InstallOptions): InstallResult;
 export declare function installHooks(names: string[], options?: InstallOptions): InstallResult[];
 export declare function getRegisteredHooksForTarget(scope?: Scope, target?: SingleTarget): string[];
@@ -54,6 +67,32 @@ export declare function getRegisteredHooks(scope?: Scope): string[];
 /** @deprecated Use getRegisteredHooks instead */
 export declare const getInstalledHooks: typeof getRegisteredHooks;
 export declare function removeHook(name: string, scope?: Scope, target?: Target): boolean;
+/**
+ * Every settings registration for the scope whose hook name does not resolve.
+ *
+ * A stale registration makes the agent spawn `hooks run <name>` on every event
+ * it is wired to, and each spawn fails — the failure is invisible to `hooks
+ * install`/`hooks remove` because nothing re-checks names already written.
+ */
+export declare function scanStaleRegistrations(scope?: Scope): StaleRegistration[];
+export interface PruneStaleResult {
+    /** Settings file edited. */
+    file: string;
+    /** The registrations removed from it. */
+    removed: StaleRegistration[];
+    /** Sibling backup of the pre-edit bytes (`<settings>.bak`). */
+    backupPath: string;
+}
+/**
+ * Remove every stale registration the scope carries, and nothing else.
+ *
+ * Edits only the entries whose own command is stale: sibling hooks in the same
+ * entry, unrelated event keys, matchers and every non-hook settings key are
+ * preserved, the file stays valid JSON, and a `.bak` sibling is written before
+ * the edit. Idempotent — a second call finds nothing stale and writes nothing.
+ * A registration whose hook resolves is never touched.
+ */
+export declare function pruneStaleRegistrations(scope?: Scope): PruneStaleResult[];
 export interface UninstallResult {
     name: string;
     removed: boolean;
@@ -81,14 +120,5 @@ export declare function removeCodewithHookEntry(configText: string, name: string
     text: string;
     removed: boolean;
 };
-/**
- * Full uninstall — the settings registration, the store directory (custom
- * hooks), the lock pin and the DB record are all removed. Bundled hooks keep
- * their package files (they belong to the package, not the store).
- *
- * Resolves custom and registry-synced hooks, which live in the custom store
- * dir, as well as bundled ones (QA-1 BUG-A / QA-4: remove was bundled-only
- * and never cleaned the store/lock/DB).
- */
 export declare function uninstallHook(name: string, scope?: Scope, target?: Target): UninstallResult;
 export {};

package/dist/lib/local-opt-in.d.ts

@@ -0,0 +1,80 @@
+import type { HooksCredentialOptions, HooksLocalOptInEnv } from "./resolver-types.js";
+/** The deliberate unhosted opt-in, canonical name first. */
+export declare const HOOKS_LOCAL_OPT_IN_ENV_KEYS: readonly ["HASNA_HOOKS_LOCAL", "HOOKS_LOCAL"];
+/** True when the operator deliberately asked for the unhosted local store. */
+export declare function isHooksLocalOptIn(env?: HooksLocalOptInEnv): boolean;
+/** Every env name that can configure a hooks authority or credential, resolver-derived. */
+export declare function hooksAuthorityEnvKeys(): string[];
+/**
+ * Does the ENVIRONMENT itself configure a hooks authority or credential?
+ *
+ * Deliberately narrower than "does a credential resolve": answering it must not
+ * touch the Keychain or the filesystem, because doing so would defeat the
+ * isolation the opt-in short-circuit exists to provide. It reads the env
+ * dictionary and nothing else.
+ *
+ * A DECLARED-BUT-BLANK variable counts as absent HERE — a blank has always been
+ * this package's spelling for "not configured", and helpers in the wild blank
+ * rather than delete. It is NOT absent once we do go hosted: the resolver
+ * refuses a blank loudly rather than falling through to another identity, which
+ * is the behaviour that matters at that point.
+ */
+export declare function hasHooksEnvAuthorityIntent(env?: HooksLocalOptInEnv): boolean;
+/** True when this environment should be served by the on-box bundled store. */
+export declare function selectsHooksLocalStore(env?: HooksLocalOptInEnv): boolean;
+/**
+ * The environment as the resolver should see it: every authority/credential
+ * variable that is DECLARED BUT BLANK removed.
+ *
+ * A blank has always been this package's spelling for "not configured".
+ * @hasna/contracts takes the opposite and, for its purposes, correct view: a
+ * declared-but-blank credential is a misconfiguration it refuses loudly rather
+ * than resolving around, because a blank that fell through would authenticate
+ * as a different principal than the operator named.
+ *
+ * Both are right at their own layer, and the mismatch is not hypothetical: an
+ * environment carrying a real `HASNA_HOOKS_API_KEY` alongside a blank legacy
+ * alias — the exact shape a scrubbed-then-overridden fixture produces — is a
+ * complete, unambiguous configuration that would otherwise be refused for the
+ * alias nobody set. Normalising here keeps "blank means unset" true at the
+ * hooks seam while leaving the resolver's stricter rule intact for everything
+ * it does receive: a value that is present is still policed, and two aliases
+ * that actually disagree still refuse.
+ */
+export declare function hooksResolverEnv<T extends HooksLocalOptInEnv>(env: T): T;
+/** The env object and credential options a hooks surface hands @hasna/contracts. */
+export interface HooksResolverInputs<T extends HooksLocalOptInEnv> {
+    /** The environment with every declared-but-blank authority variable removed. */
+    env: T;
+    /** The chain options, with the Keychain tier's ambient gate already decided. */
+    credentials: HooksCredentialOptions;
+}
+/**
+ * Build the resolver's inputs: the normalised environment AND the credential
+ * options that keep the machine's Keychain tier reachable across it.
+ *
+ * WHY THIS IS NOT JUST {@link hooksResolverEnv}. Blanking a variable and
+ * deleting it are not the same operation to @hasna/contracts, because dropping
+ * a key forces us to hand the resolver a COPY, and the resolver gates its
+ * ambient tiers on OBJECT IDENTITY (`env === process.env`, or the registry
+ * symbol its own snapshot carries). A copy is, by that test, a caller-built
+ * world — the hermetic seam — so the Keychain is outside it and tier 3 turns
+ * itself off. Silently: there is no error, no warning and no diagnostic.
+ *
+ * The consequence is the one failure this whole ruling exists to prevent. On a
+ * station whose Keychain holds `hasna.credentials.hooks.api-key`, ONE
+ * declared-but-blank authority variable dropped the run from the Keychain
+ * identity to whatever came next: to `~/.hasna/hooks/config/credentials`, a
+ * DIFFERENT principal, with no notice; or, with nothing on disk, to a bare
+ * REMOTE_API_CONFIG_MISSING on a station that is in fact configured. A
+ * deliberate tier must never fall through to another identity, so the gate is
+ * decided HERE, on the original env, and carried across the copy as the
+ * documented `keychain.enabled` control rather than being left to an identity
+ * test the copy cannot pass.
+ *
+ * An explicit `enabled` from the caller still wins, and an injected `run`
+ * (which @hasna/contracts already treats as "enabled") is left alone, so the
+ * hermetic seam tests rely on is untouched. When there is no blank to remove
+ * the inputs pass through by identity, exactly as before.
+ */
+export declare function hooksResolverInputs<T extends HooksLocalOptInEnv>(env: T, credentials?: HooksCredentialOptions): HooksResolverInputs<T>;

package/dist/lib/profiles.d.ts

@@ -20,6 +20,16 @@ export interface CreateProfileInput {
     agent_type: "claude" | "gemini" | "custom";
     name?: string;
 }
+/**
+ * The profiles directory under the effective data root.
+ *
+ * Resolved on every call, never snapshotted at module load: the effective
+ * data root is env-driven (HASNA_HOOKS_DATA_DIR / HASNA_HOOKS_HOME / the XDG
+ * adoption in app-home), and bun test runs test files in one process with a
+ * SHARED process.env — a module-load snapshot froze the dir to whatever the
+ * env held at import time, so a concurrent file pinning a data-root override
+ * silently moved every profile operation of this module with it.
+ */
 export declare function getProfilesDir(): string;
 export declare function createProfile(input: CreateProfileInput): AgentProfile;
 export declare function getProfile(id: string): AgentProfile | null;

package/dist/lib/registration.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Settings registration checks shared by the CLI doctor and the MCP
+ * hooks_doctor.
+ *
+ * Event and matcher are separate settings fields — settings.hooks[event] is
+ * an array of { matcher?, hooks: [...] } entries — so a composite event such
+ * as 'PreToolUse:Bash' must be split before lookup, never used as a key.
+ */
+/** A settings registration whose hook name cannot resolve. */
+export interface StaleRegistration {
+    /** Settings file the registration lives in. */
+    file: string;
+    /** Settings event key holding the entry (PreToolUse, …). */
+    event: string;
+    /** The registered hook name that does not resolve. */
+    hook: string;
+    /** The raw command string from the settings entry. */
+    command: string;
+}
+/**
+ * Find settings registrations whose hook does not resolve.
+ *
+ * A registration is a `hooks run <name>` (or legacy `hook-<name>`) command;
+ * it is stale when `resolveHook(name)` finds no bundled, custom or stored
+ * hook — exactly the lookup `hooks run` performs, so a stale registration
+ * fails on every tool call it is wired to. Direct-path wiring outside the
+ * installer's own command forms is reported by `countSettingsWiring`, never
+ * treated as a hook registration.
+ */
+export declare function findStaleRegistrations(settings: Record<string, unknown>, file: string, resolves?: (name: string) => boolean): StaleRegistration[];
+/**
+ * Whether two tool matchers can select the same tool call. Deliberately loose
+ * (identical, or one a substring of the other) — a false positive costs one
+ * advisory warning, a false negative costs a silently disarmed guard.
+ */
+export declare function matchersOverlap(a: string, b: string): boolean;
+/** The metadata slice `findRewriteOverlaps` needs from a hook. */
+export interface RewriteHookInfo {
+    matcher?: string;
+    event?: string;
+    events?: string[];
+    rewritesInput?: boolean;
+}
+/** Two installed hooks that both rewrite the tool input on the same tool. */
+export interface RewriteOverlap {
+    hooks: [string, string];
+    event: string;
+    matchers: [string, string];
+}
+/**
+ * Installed hooks that both rewrite the tool input
+ * (`hookSpecificOutput.updatedInput`) on an overlapping PreToolUse matcher.
+ *
+ * This is a real defect, not a style nit: the harness applies ONE rewrite per
+ * tool call, so one of the two guards is silently disarmed. The installer
+ * refuses the pairing up front; doctor reports it for settings files it did
+ * not write (hand-edited, or written before the rule existed).
+ */
+export declare function findRewriteOverlaps(names: string[], lookup: (name: string) => RewriteHookInfo | undefined): RewriteOverlap[];
+/**
+ * Whether a hook is registered in a settings file.
+ *
+ * An entry matches when it carries a `hooks run <name>` command and, when the
+ * hook declares a matcher, the entry's matcher is absent (fires on all tools)
+ * or consistent with the hook's matcher (equal, or one regex matches the
+ * other).
+ */
+/**
+ * Count every raw hook entry wired in a settings file — including
+ * direct-path entries that never went through the CLI (`command` values that
+ * are not `hooks run <name>`). Doctor reports this count alongside the
+ * registered count so its "healthy" verdict names its bounds (P2-16b).
+ */
+export declare function countSettingsWiring(settings: Record<string, unknown>): number;
+export declare function hookRegisteredInSettings(settings: Record<string, unknown>, name: string, eventSpec: string, hookMatcher: string): boolean;

package/dist/lib/registry.d.ts

@@ -13,6 +13,20 @@ export interface HookMeta {
     events?: HookEvent[];
     matcher: string;
     tags: string[];
+    /**
+     * This hook rewrites the tool input (`hookSpecificOutput.updatedInput`).
+     * The agent harness keeps ONE rewrite per tool call — last writer wins — so
+     * two input-rewriting hooks on overlapping PreToolUse matchers silently
+     * disarm each other. Install refuses that pairing, and `hooks doctor`
+     * reports it.
+     */
+    rewritesInput?: boolean;
+    /**
+     * Timeout (seconds) written into the agent's settings entry for this hook.
+     * The harness default is 600s, and a TIMED-OUT HOOK DOES NOT BLOCK: a guard
+     * that needs a verdict on stdout must declare a timeout it can meet.
+     */
+    timeoutSeconds?: number;
 }
 export declare const CATEGORIES: readonly ["Git Safety", "Code Quality", "Security", "Notifications", "Context Management", "Workflow Automation", "Environment", "Permissions", "Observability", "Agent Teams"];
 export type Category = (typeof CATEGORIES)[number];

package/dist/lib/resolver-types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The @hasna/contracts client types that @hasna/hooks PUBLISHES or hands back
+ * across its public seam, spelled locally.
+ *
+ * WHY THIS FILE EXISTS. `@hasna/contracts` is a BUILD-TIME dependency of this
+ * package (pinned 1.0.2, inlined by `bun build --target bun`), so the emitted
+ * `dist/**/*.d.ts` must never `import ... from "@hasna/contracts/client"` —
+ * a published declaration that references a package consumers do not have is
+ * a broken install (hasna/apps#1782). Every public signature therefore uses
+ * these local spellings, which are structurally identical to the resolver's
+ * own types (`CredentialChainOptions` / `KeychainCommandResult`). The
+ * `credential chain shape` test in `transport.test.ts` pins the local
+ * spellings against the real @hasna/contracts types so they cannot drift.
+ */
+export type HooksLocalOptInEnv = Record<string, string | undefined>;
+/** What an injected `security` runner returns: an exit status plus output. */
+export interface HooksKeychainCommandResult {
+    /** Exit status; null when the tool could not be started or was killed. */
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+/** Tier 3 (Keychain) controls — structurally `KeychainTierOptions`. */
+export interface HooksKeychainTierOptions {
+    /** Whether the Keychain is consulted for a caller-built env object. */
+    enabled?: boolean;
+    /** Defaults to `process.platform`; the tier exists only on `"darwin"`. */
+    platform?: string;
+    /** The machine's host name when `HASNA_STATION` is unset. */
+    hostname?: () => string;
+    /** The `security` runner. Defaults to spawning `/usr/bin/security`. */
+    run?: (argv: readonly string[]) => HooksKeychainCommandResult;
+}
+/**
+ * Tier-1 credential inputs and Keychain-tier controls — structurally
+ * `CredentialChainOptions` from @hasna/contracts/client, spelled locally.
+ */
+export interface HooksCredentialOptions {
+    /** Tier 1: an explicit key, e.g. from `--api-key`. */
+    apiKey?: string;
+    /** Tier 1: an explicit profile name. Beats `HASNA_PROFILE`. */
+    profile?: string;
+    /** Tier 3: Keychain controls — a fake `security` runner in tests, an opt-out on CI. */
+    keychain?: HooksKeychainTierOptions;
+}

package/dist/lib/sync.d.ts

@@ -6,7 +6,16 @@
  * failure mid-sync leaves the local store untouched. Local-only hooks are
  * never deleted by a remote sync.
  */
+import type { HooksCredentialOptions } from "./resolver-types.js";
 import { parseManifest } from "./manifest.js";
+type Env = Record<string, string | undefined>;
+export interface HooksSyncOptions {
+    dryRun?: boolean;
+    /** Injectable environment (tests). Defaults to `process.env`. */
+    env?: Env;
+    /** Injectable credential-chain inputs (tests: fake `security` runner). */
+    credentials?: HooksCredentialOptions;
+}
 export interface SyncDiff {
     added: string[];
     updated: string[];
@@ -39,12 +48,8 @@ interface RemoteLock {
         versions?: string[];
     }>;
 }
-export declare function planSync(options?: {
-    dryRun?: boolean;
-}): Promise<SyncPlan>;
-export declare function syncHooks(options?: {
-    dryRun?: boolean;
-}): Promise<SyncPlan>;
+export declare function planSync(options?: HooksSyncOptions): Promise<SyncPlan>;
+export declare function syncHooks(options?: HooksSyncOptions): Promise<SyncPlan>;
 /**
  * One fully-validated artifact ready to be committed. Nothing has touched
  * the store at this point: every fetch, sha check and manifest parse has
@@ -64,7 +69,7 @@ export interface StagedSyncArtifact {
  * written. A failure here (network, sha mismatch, malformed manifest,
  * containment violation) throws with the store untouched.
  */
-export declare function stageSyncArtifacts(apiUrl: string, names: string[], remoteLock: RemoteLock): Promise<StagedSyncArtifact[]>;
+export declare function stageSyncArtifacts(apiUrl: string, apiKey: string, names: string[], remoteLock: RemoteLock): Promise<StagedSyncArtifact[]>;
 /**
  * P1-9 commit phase, ordered so a mid-commit failure cannot leave a partial
  * store that reads as trusted:
@@ -101,5 +106,5 @@ export interface PinnedHookInstall {
  * the user is fetched from the versioned registry — older-than-latest pins
  * are first-class, never rejected as "not the latest".
  */
-export declare function fetchPinnedHook(name: string, version: string, apiUrl: string): Promise<PinnedHookInstall>;
+export declare function fetchPinnedHook(name: string, version: string, apiUrl: string, apiKey: string): Promise<PinnedHookInstall>;
 export {};

package/dist/lib/transport.d.ts

@@ -0,0 +1,87 @@
+import type { HooksCredentialOptions, HooksLocalOptInEnv } from "./resolver-types.js";
+/** The unhosted mode: bundled registry + local SQLite store. Never a default. */
+export type HooksTransportMode = "remote" | "local";
+/** The resolved remote-registry authority pair. Never carries a value besides `apiKey`. */
+export interface HooksRemoteAuthority {
+    /**
+     * Registry origin WITHOUT the `/v1` suffix the resolver appends — the sync
+     * client composes `/api/v1/...` routes on top of it.
+     */
+    origin: string;
+    /** The credential, resolved together with the authority it will be sent to. */
+    apiKey: string;
+    /** WHERE the authority came from: an env key NAME, a Keychain item reference, a file PATH, or "default". */
+    apiUrlSource: string | null;
+    /** WHERE the credential came from: an env key NAME, a Keychain item reference, or a file PATH. Never a value. */
+    apiKeySource: string | null;
+    /** Which tier of the chain supplied the credential. */
+    apiKeyTier: string | null;
+    /** The resolver's `<origin>/v1` base, for diagnostics. */
+    v1BaseUrl: string;
+    /** Human-readable warning, or null. Never contains secret values. */
+    warning: string | null;
+}
+/**
+ * The transport decision every hosted surface makes: remote (resolver-backed)
+ * or local (explicit opt-in, resolver never consulted).
+ *
+ * Local mode returns `authority: null` and carries no key. Remote mode always
+ * carries a fully resolved pair — the seam throws before returning a
+ * half-configured one.
+ */
+export interface HooksTransportResolution {
+    mode: HooksTransportMode;
+    /** `"local-opt-in"` for the deliberate unhosted store, else `"<api key source>+<api url source>"`. */
+    source: string;
+    /** The resolved remote pair; null in local mode. */
+    authority: HooksRemoteAuthority | null;
+}
+/** Where the one-line local-mode notice goes. Defaults to `process.stderr`. */
+export type HooksTransportNotice = (line: string) => void;
+/** Reset the once-per-process local-mode notice. Test seam only. */
+export declare function __resetHooksLocalNotice(): void;
+/**
+ * Announce the unhosted mode on stderr, once per process. Surfaces that never
+ * resolve the transport (the CLI gate opening through the opt-in) still have
+ * to SAY the run is local — the "local on stderr" doctrine (2026-09-04).
+ */
+export declare function announceHooksLocalMode(reason?: string, notice?: HooksTransportNotice): void;
+/** Strip the `/v1` suffix the resolver normalised onto the authority. */
+export declare function hooksRegistryOrigin(v1BaseUrl: string): string;
+/**
+ * Re-throw a `@hasna/contracts` resolution failure as hooks' own fail-closed
+ * diagnostic, preserving the resolver's message (which names every tier it
+ * consulted) behind the stable `REMOTE_API_*` code callers match on. Nothing
+ * here ever returns a client or a local store: every arm throws.
+ */
+export declare function rethrowHooksAuthorityFailure(error: unknown): never;
+/** Tier-1 credential inputs and Keychain-tier controls, forwarded verbatim. */
+export type { HooksCredentialOptions } from "./resolver-types.js";
+export interface HooksTransportOptions {
+    /** Tier-1 credential inputs (`--api-key` / `--profile`) and the injectable `security` runner tests use. */
+    credentials?: HooksCredentialOptions;
+    /** Where the one-line local-mode notice goes. Defaults to `process.stderr`. */
+    notice?: HooksTransportNotice;
+}
+/**
+ * Resolve the hooks transport. The deliberate unhosted opt-in is answered
+ * first and WITHOUT consulting the resolver; otherwise `@hasna/contracts`
+ * resolves the credential AND the authority together as one strict pair, and
+ * any failure to do so is a throw — the client never defaults to the on-box
+ * store (owner ruling 2026-09-04). Resolved fresh on every call.
+ */
+export declare function resolveHooksTransport(env?: HooksLocalOptInEnv, options?: HooksTransportOptions): HooksTransportResolution;
+/**
+ * The registry keys the publish surface checks. Local-by-design commands
+ * (`hooks serve`) never pick a transport; they only need to know whether a
+ * credential exists to honour a PUT. Resolved fresh on every call, through the
+ * same chain as {@link resolveHooksTransport}, so a key rotation heals a
+ * long-lived server without a restart.
+ *
+ * Returns `undefined` when no credential resolves — reads stay open and
+ * publish refuses — and THROWS on a deliberate tier that exists but cannot be
+ * honoured (a locked Keychain, an unsafe credential file), because falling
+ * through to another identity is the one silent failure the chain exists to
+ * end.
+ */
+export declare function resolveHooksServePublishKey(env?: HooksLocalOptInEnv, options?: HooksTransportOptions): string | undefined;

package/dist/openapi.d.ts

@@ -209,7 +209,7 @@ export declare const openApiDocument: {
             readonly apiKey: {
                 readonly type: "http";
                 readonly scheme: "bearer";
-                readonly description: "The registry API key (HASNA_HOOKS_API_KEY / HOOKS_API_KEY).";
+                readonly description: "The registry API key — resolved by the client through the @hasna/contracts chain (HASNA_HOOKS_API_KEY, the Keychain item hasna.credentials.hooks.api-key, or ~/.hasna/hooks/config/credentials); the server compares the inbound bearer/x-api-key value.";
             };
         };
     };