@cratis/chronicle 0.0.1

package/Schemas/JsonSchemaGenerator.ts

@@ -0,0 +1,107 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { Guid } from '@cratis/fundamentals';
+import { JsonSchema } from './JsonSchema';
+import { TypeIntrospector } from '../types';
+
+/**
+ * Generates JSON schemas for class constructors using reflection metadata.
+ */
+export class JsonSchemaGenerator {
+    private static readonly _knownTypeFormats = new Map<Function, { type: JsonSchema['type']; format: string }>([
+        [Guid, { type: 'string', format: 'guid' }],
+        [Date, { type: 'string', format: 'date-time' }]
+    ]);
+
+    private static readonly _formatAliases = new Map<string, string>([
+        ['uuid', 'guid']
+    ]);
+
+    /**
+     * Creates an empty schema for a type name.
+     * @param title - The title to use for the schema.
+     * @returns An empty object schema.
+     */
+    static createEmptySchema(title: string): JsonSchema {
+        return {
+            $schema: 'https://json-schema.org/draft/2020-12/schema',
+            title,
+            type: 'object',
+            properties: {},
+            required: [],
+            additionalProperties: false
+        };
+    }
+
+    /**
+     * Generates a JSON schema for a class constructor.
+     * @param target - The class constructor to generate schema for.
+     * @param members - Optional pre-introspected members for reuse.
+     * @returns The generated JSON schema.
+     */
+    static generate(target: Function, members?: ReadonlyMap<string, Function | undefined>): JsonSchema {
+        const membersToUse = members ?? TypeIntrospector.getMembers(target);
+        const schemaProperties: Record<string, JsonSchema> = {};
+        for (const [memberName, memberType] of membersToUse.entries()) {
+            schemaProperties[memberName] = this.mapRuntimeTypeToSchema(memberType);
+        }
+
+        return {
+            ...this.createEmptySchema(target.name),
+            properties: schemaProperties,
+            required: Array.from(membersToUse.keys()),
+        };
+    }
+
+    private static mapRuntimeTypeToSchema(runtimeType: Function | undefined): JsonSchema {
+        const knownTypeFormat = this.getKnownTypeFormat(runtimeType);
+        if (knownTypeFormat) {
+            return knownTypeFormat;
+        }
+
+        if (runtimeType === String) {
+            return { type: 'string' };
+        }
+
+        if (runtimeType === Number) {
+            return { type: 'number' };
+        }
+
+        if (runtimeType === Boolean) {
+            return { type: 'boolean' };
+        }
+
+        if (runtimeType === Array) {
+            return { type: 'array', items: { type: 'object' } };
+        }
+
+        if (runtimeType && runtimeType !== Object) {
+            return this.generate(runtimeType);
+        }
+
+        return { type: 'object' };
+    }
+
+    private static getKnownTypeFormat(runtimeType: Function | undefined): JsonSchema | undefined {
+        if (!runtimeType) {
+            return undefined;
+        }
+
+        const known = this._knownTypeFormats.get(runtimeType);
+        if (!known) {
+            return undefined;
+        }
+
+        return {
+            type: known.type,
+            format: this.normalizeFormat(known.format)
+        };
+    }
+
+    private static normalizeFormat(format: string): string {
+        const normalized = format.toLowerCase();
+        return this._formatAliases.get(normalized) ?? normalized;
+    }
+}

package/Schemas/index.ts

@@ -0,0 +1,6 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { JsonSchemaGenerator } from './JsonSchemaGenerator';
+export { jsonSchemaProperty, getTrackedJsonSchemaProperties } from './jsonSchemaProperty';
+export type { JsonSchema } from './JsonSchema';

package/Schemas/jsonSchemaProperty.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import 'reflect-metadata';
+import { TypeIntrospector } from '../types';
+
+/**
+ * Decorates a class property so its runtime type metadata can be used for JSON schema generation.
+ * @returns A property decorator.
+ */
+export function jsonSchemaProperty(): PropertyDecorator {
+    return (target: object, propertyKey: string | symbol) => {
+        TypeIntrospector.trackProperty(target.constructor as Function, propertyKey.toString());
+    };
+}
+
+/**
+ * Gets all tracked schema properties for a type.
+ * @param target - The class constructor to inspect.
+ * @returns The tracked property names.
+ */
+export function getTrackedJsonSchemaProperties(target: Function): string[] {
+    return TypeIntrospector.getTrackedProperties(target);
+}

package/Tracing.ts

@@ -0,0 +1,21 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { trace } from '@opentelemetry/api';
+
+/**
+ * The name of the Chronicle instrumentation library.
+ * Use this name to filter or configure Chronicle client spans in your observability backend.
+ */
+export const ChronicleInstrumentationName = '@cratis/chronicle';
+
+/**
+ * The OpenTelemetry tracer used by the Chronicle client for all instrumentation.
+ * This tracer is pre-configured with the Chronicle library name and is used to
+ * create spans around every client operation.
+ *
+ * If your application has configured an OpenTelemetry SDK (e.g. via {@link https://www.npmjs.com/package/@opentelemetry/sdk-node}),
+ * Chronicle spans will automatically flow through it.
+ * If no SDK is configured, the no-op tracer is used and no overhead is incurred.
+ */
+export const ChronicleTracer = trace.getTracer(ChronicleInstrumentationName);

package/artifacts/DefaultClientArtifactsProvider.ts

@@ -0,0 +1,56 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { IClientArtifactsProvider } from './IClientArtifactsProvider';
+import { DecoratorType } from '../types/DecoratorType';
+import { TypeDiscoverer } from '../types/TypeDiscoverer';
+
+/**
+ * Represents the default provider for discovered client artifacts.
+ */
+export class DefaultClientArtifactsProvider implements IClientArtifactsProvider {
+    /** Singleton default provider using the shared {@link TypeDiscoverer}. */
+    static readonly default = new DefaultClientArtifactsProvider(TypeDiscoverer.default);
+
+    /**
+     * Initializes a new instance of the {@link DefaultClientArtifactsProvider} class.
+     * @param discoverer - The discoverer instance that provides discovered types.
+     */
+    constructor(private readonly discoverer: TypeDiscoverer) {}
+
+    /** @inheritdoc */
+    get eventTypes(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.EventType);
+    }
+
+    /** @inheritdoc */
+    get readModels(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.ReadModel);
+    }
+
+    /** @inheritdoc */
+    get reactors(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.Reactor);
+    }
+
+    /** @inheritdoc */
+    get reducers(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.Reducer);
+    }
+
+    /** @inheritdoc */
+    get constraints(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.Constraint);
+    }
+
+    /** @inheritdoc */
+    get projections(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.Projection);
+    }
+
+    /** @inheritdoc */
+    get modelBoundProjections(): Constructor[] {
+        return this.discoverer.getTypesByDecoratorType(DecoratorType.ModelBoundProjection);
+    }
+}

package/artifacts/IClientArtifactsProvider.ts

@@ -0,0 +1,30 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+
+/**
+ * Defines a provider capable of returning discovered client artifact types.
+ */
+export interface IClientArtifactsProvider {
+    /** Gets discovered event type constructors. */
+    readonly eventTypes: Constructor[];
+
+    /** Gets discovered read model constructors. */
+    readonly readModels: Constructor[];
+
+    /** Gets discovered reactor constructors. */
+    readonly reactors: Constructor[];
+
+    /** Gets discovered reducer constructors. */
+    readonly reducers: Constructor[];
+
+    /** Gets discovered constraint constructors. */
+    readonly constraints: Constructor[];
+
+    /** Gets discovered declarative projection constructors. */
+    readonly projections: Constructor[];
+
+    /** Gets discovered model-bound projection constructors. */
+    readonly modelBoundProjections: Constructor[];
+}

package/artifacts/index.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export type { IClientArtifactsProvider } from './IClientArtifactsProvider';
+export { DefaultClientArtifactsProvider } from './DefaultClientArtifactsProvider';

package/connection/ChronicleConnection.ts

@@ -0,0 +1,226 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import {
+	ChronicleConnection as ContractsChronicleConnection,
+	ConnectionServiceDefinition,
+	type ChronicleConnectionOptions,
+	type ChronicleServices
+} from '@cratis/chronicle.contracts';
+import type { ConnectionServiceClient } from '@cratis/chronicle.contracts';
+import { createClientFactory } from 'nice-grpc';
+
+/**
+ * Wraps the contracts connection and allows recreating the underlying channel
+ * during reconnect while keeping a stable object reference for consumers.
+ */
+export class ChronicleConnection implements ChronicleServices {
+	private _inner: ContractsChronicleConnection;
+	private _authenticatedConnectionService?: ConnectionServiceClient;
+
+	/**
+	 * Creates a new {@link ChronicleConnection}.
+	 * @param _options - Connection options used to create and recreate the underlying connection.
+	 */
+	constructor(private readonly _options: ChronicleConnectionOptions) {
+		this._inner = this.createInnerConnection();
+	}
+
+	/**
+	 * Gets the connection string currently used by the inner connection.
+	 */
+	get connectionString() {
+		return this._inner.connectionString;
+	}
+
+	/**
+	 * Gets whether the current inner connection is connected.
+	 */
+	get isConnected(): boolean {
+		return this._inner.isConnected;
+	}
+
+	/**
+	 * Event stores service.
+	 */
+	get eventStores() {
+		return this._inner.eventStores;
+	}
+
+	/**
+	 * Namespaces service.
+	 */
+	get namespaces() {
+		return this._inner.namespaces;
+	}
+
+	/**
+	 * Recommendations service.
+	 */
+	get recommendations() {
+		return this._inner.recommendations;
+	}
+
+	/**
+	 * Identities service.
+	 */
+	get identities() {
+		return this._inner.identities;
+	}
+
+	/**
+	 * Event sequences service.
+	 */
+	get eventSequences() {
+		return this._inner.eventSequences;
+	}
+
+	/**
+	 * Event types service.
+	 */
+	get eventTypes() {
+		return this._inner.eventTypes;
+	}
+
+	/**
+	 * Constraints service.
+	 */
+	get constraints() {
+		return this._inner.constraints;
+	}
+
+	/**
+	 * Observers service.
+	 */
+	get observers() {
+		return this._inner.observers;
+	}
+
+	/**
+	 * Failed partitions service.
+	 */
+	get failedPartitions() {
+		return this._inner.failedPartitions;
+	}
+
+	/**
+	 * Reactors service.
+	 */
+	get reactors() {
+		return this._inner.reactors;
+	}
+
+	/**
+	 * Reducers service.
+	 */
+	get reducers() {
+		return this._inner.reducers;
+	}
+
+	/**
+	 * Projections service.
+	 */
+	get projections() {
+		return this._inner.projections;
+	}
+
+	/**
+	 * Read models service.
+	 */
+	get readModels() {
+		return this._inner.readModels;
+	}
+
+	/**
+	 * Jobs service.
+	 */
+	get jobs() {
+		return this._inner.jobs;
+	}
+
+	/**
+	 * Event seeding service.
+	 */
+	get eventSeeding() {
+		return this._inner.eventSeeding;
+	}
+
+	/**
+	 * Server service.
+	 */
+	get server() {
+		return this._inner.server;
+	}
+
+	/**
+	 * Connection service — used to register this client with the kernel keep-alive mechanism.
+	 * Uses an authenticated client (same auth middleware as all other services).
+	 */
+	get connections(): ConnectionServiceClient {
+		if (!this._authenticatedConnectionService) {
+			// The inner connectionService lacks auth middleware. Create a properly
+			// authenticated client using the same factory pattern as createServices().
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const inner = this._inner as any;
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const factory = createClientFactory().use(inner.createAuthMiddleware() as any);
+			this._authenticatedConnectionService = factory.create(ConnectionServiceDefinition, inner.channel) as unknown as ConnectionServiceClient;
+		}
+		return this._authenticatedConnectionService;
+	}
+
+	/**
+	 * Connects the current inner connection.
+	 */
+	async connect(): Promise<void> {
+		await this._inner.connect();
+	}
+
+	/**
+	 * Recreates the inner connection (new gRPC channel) without calling connect().
+	 * Use this before probing with a real RPC call to ensure a fresh IDLE channel.
+	 */
+	resetChannel(): void {
+		try {
+			this._inner.disconnect();
+		} catch {
+			// Best-effort disconnect before re-creating the channel.
+		}
+		this._inner = this.createInnerConnection();
+		this._authenticatedConnectionService = undefined;
+	}
+
+	/**
+	 * Recreates and connects the inner connection.
+	 */
+	async reconnect(): Promise<void> {
+		try {
+			this._inner.disconnect();
+		} catch {
+			// Best-effort disconnect before re-creating the channel.
+		}
+
+		this._inner = this.createInnerConnection();
+		await this._inner.connect();
+	}
+
+	/**
+	 * Disconnects the current inner connection.
+	 */
+	disconnect(): void {
+		this._inner.disconnect();
+	}
+
+	/**
+	 * Disposes the current inner connection.
+	 */
+	dispose(): void {
+		this._inner.dispose();
+	}
+
+	private createInnerConnection(): ContractsChronicleConnection {
+		return new ContractsChronicleConnection(this._options);
+	}
+}
+
+export type { ChronicleConnectionOptions } from '@cratis/chronicle.contracts';

package/connection/ChronicleConnectionString.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { ChronicleConnectionString } from '@cratis/chronicle.contracts';

package/connection/ChronicleServices.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { ChronicleServices } from '@cratis/chronicle.contracts';

package/connection/ConnectionLifecycle.ts

@@ -0,0 +1,77 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Guid } from '@cratis/fundamentals';
+
+export type ConnectedHandler = () => Promise<void>;
+export type DisconnectedHandler = () => Promise<void>;
+
+/**
+ * Represents the lifecycle state for a Chronicle connection.
+ */
+export class ConnectionLifecycle {
+    private readonly _onConnected = new Set<ConnectedHandler>();
+    private readonly _onDisconnected = new Set<DisconnectedHandler>();
+
+    private _isConnected = false;
+    private _connectionId: string = Guid.create().toString();
+
+    /**
+     * Gets whether the connection is currently connected.
+     */
+    get isConnected(): boolean {
+        return this._isConnected;
+    }
+
+    /**
+     * Gets the current connection identifier.
+     */
+    get connectionId(): string {
+        return this._connectionId;
+    }
+
+    /**
+     * Registers a callback for when the connection is connected.
+     * @param handler - Callback to invoke on connect.
+     * @returns A function that unsubscribes the callback.
+     */
+    onConnected(handler: ConnectedHandler): () => void {
+        this._onConnected.add(handler);
+        return () => this._onConnected.delete(handler);
+    }
+
+    /**
+     * Registers a callback for when the connection is disconnected.
+     * @param handler - Callback to invoke on disconnect.
+     * @returns A function that unsubscribes the callback.
+     */
+    onDisconnected(handler: DisconnectedHandler): () => void {
+        this._onDisconnected.add(handler);
+        return () => this._onDisconnected.delete(handler);
+    }
+
+    /**
+     * Marks lifecycle as connected and invokes connected handlers.
+     */
+    async connected(onError: (error: unknown) => void): Promise<void> {
+        this._isConnected = true;
+        await Promise.all([...this._onConnected].map(handler => this.invokeHandler(handler, onError)));
+    }
+
+    /**
+     * Marks lifecycle as disconnected and invokes disconnected handlers.
+     */
+    async disconnected(onError: (error: unknown) => void): Promise<void> {
+        this._isConnected = false;
+        await Promise.all([...this._onDisconnected].map(handler => this.invokeHandler(handler, onError)));
+        this._connectionId = Guid.create().toString();
+    }
+
+    private async invokeHandler(handler: () => Promise<void>, onError: (error: unknown) => void): Promise<void> {
+        try {
+            await handler();
+        } catch (error) {
+            onError(error);
+        }
+    }
+}

package/connection/DateTimeOffset.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { DateTimeOffset } from '@cratis/chronicle.contracts';

package/connection/Guid.ts

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { Guid } from '@cratis/chronicle.contracts';

package/connection/TokenProvider.ts

@@ -0,0 +1,13 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { ITokenProvider } from '@cratis/chronicle.contracts';
+
+export {
+	NoOpTokenProvider,
+	OAuthTokenProvider
+} from '@cratis/chronicle.contracts';
+
+export type { ITokenProvider } from '@cratis/chronicle.contracts';
+
+export type TokenProvider = ITokenProvider;

package/connection/index.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export { ChronicleConnection } from './ChronicleConnection';
+export { ChronicleConnectionString } from './ChronicleConnectionString';
+export { ChronicleServices } from './ChronicleServices';
+export { DateTimeOffset } from './DateTimeOffset';
+export { Guid } from './Guid';
+export { TokenProvider } from './TokenProvider';

package/dist/ChronicleClient.d.ts

@@ -0,0 +1,55 @@
+import { ChronicleOptions } from './ChronicleOptions';
+import { EventStoreName } from './EventStoreName';
+import { EventStoreNamespaceName } from './EventStoreNamespaceName';
+import { IChronicleClient } from './IChronicleClient';
+import { IEventStore } from './IEventStore';
+/**
+ * Implements {@link IChronicleClient} by managing a gRPC connection to the
+ * Chronicle Kernel via {@link ChronicleConnection}.
+ *
+ * Create a client by providing {@link ChronicleOptions} configured with a connection string:
+ *
+ * ```typescript
+ * const client = new ChronicleClient(ChronicleOptions.fromConnectionString('chronicle://localhost:35000'));
+ * const store = await client.getEventStore('MyStore');
+ * await store.eventLog.append('my-entity-id', new MyEvent('data'));
+ * client.dispose();
+ * ```
+ */
+export declare class ChronicleClient implements IChronicleClient {
+    readonly options: ChronicleOptions;
+    private static readonly _healthCheckIntervalMs;
+    private readonly _connection;
+    private readonly _stores;
+    private readonly _lifecycle;
+    private readonly _logger;
+    private _watchdogHandle?;
+    private _connectOperation?;
+    private _reconnectOperation?;
+    private _discoveryOperation?;
+    private _isDisposed;
+    private _keepAliveAbortController?;
+    /**
+     * Creates a new {@link ChronicleClient} using the provided options.
+     * @param options - The options to configure the client, including the connection string.
+     */
+    constructor(options: ChronicleOptions);
+    /** @inheritdoc */
+    getEventStore(name: string | EventStoreName, namespace?: string | EventStoreNamespaceName): Promise<IEventStore>;
+    /** @inheritdoc */
+    getEventStores(): Promise<EventStoreName[]>;
+    /** @inheritdoc */
+    dispose(): void;
+    private connectWithRetry;
+    private ensureConnected;
+    private reconnect;
+    private withReconnect;
+    private shouldReconnect;
+    private toErrorMessage;
+    private startConnectionWatchdog;
+    private runHealthCheck;
+    private startKernelKeepAlive;
+    private runKeepAliveLoop;
+    private registerArtifactsForStore;
+}
+//# sourceMappingURL=ChronicleClient.d.ts.map

package/dist/ChronicleClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChronicleClient.d.ts","sourceRoot":"","sources":["../ChronicleClient.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAItD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IAsBxC,QAAQ,CAAC,OAAO,EAAE,gBAAgB;IArB9C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAQ;IAEtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAsB;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;IAC9D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IAExD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAErB;IAEH,OAAO,CAAC,eAAe,CAAC,CAAiC;IACzD,OAAO,CAAC,iBAAiB,CAAC,CAAgB;IAC1C,OAAO,CAAC,mBAAmB,CAAC,CAAgB;IAC5C,OAAO,CAAC,mBAAmB,CAAC,CAAgB;IAC5C,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,yBAAyB,CAAC,CAAkB;IAEpD;;;OAGG;gBACkB,OAAO,EAAE,gBAAgB;IAgD9C,kBAAkB;IACZ,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,uBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC;IA0DtH,kBAAkB;IACZ,cAAc,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IA0BjD,kBAAkB;IAClB,OAAO,IAAI,IAAI;YAsBD,gBAAgB;YA8ChB,eAAe;YAkBf,SAAS;YAgDT,aAAa;IAa3B,OAAO,CAAC,eAAe;IAwBvB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,uBAAuB;YAQjB,cAAc;YAad,oBAAoB;YAuBpB,gBAAgB;YAuBhB,yBAAyB;CAmB1C"}