@agentick/kernel 0.0.1

package/dist/guard.d.ts

@@ -0,0 +1,65 @@
+import type { Middleware, ProcedureEnvelope } from "./procedure";
+/**
+ * Guard function that inspects the procedure envelope to decide allow/deny.
+ *
+ * - Return `true` to allow execution.
+ * - Return `false` to deny (createGuard constructs a GuardError from config).
+ * - Throw a `GuardError` directly for full control over the error.
+ */
+export type GuardFn = (envelope: ProcedureEnvelope<any[]>) => boolean | Promise<boolean>;
+/**
+ * Configuration for createGuard.
+ */
+export interface GuardConfig {
+    /** Guard name (for debugging, telemetry, error details) */
+    name?: string;
+    /**
+     * Denial reason when the guard fn returns `false`.
+     * String or function that receives the envelope for dynamic messages.
+     * Ignored when the guard fn throws its own error.
+     */
+    reason?: string | ((envelope: ProcedureEnvelope<any[]>) => string);
+    /** Guard type discriminator (e.g., "role", "guardrail", "rate-limit") */
+    guardType?: string;
+}
+/**
+ * Create a guard middleware from a predicate function.
+ *
+ * The guard runs before the procedure handler:
+ * - If the fn returns `true`, execution continues.
+ * - If the fn returns `false`, a `GuardError` is thrown (using config for the message).
+ * - If the fn throws a `GuardError`, it propagates directly (full control).
+ *
+ * @example Simple boolean guard
+ * ```typescript
+ * const adminOnly = createGuard(
+ *   (envelope) => envelope.context.user?.roles?.includes("admin") ?? false,
+ * );
+ * ```
+ *
+ * @example Config with dynamic reason
+ * ```typescript
+ * const roleGuard = createGuard({
+ *   name: "role-guard",
+ *   guardType: "role",
+ *   reason: (envelope) => `User ${envelope.context.user?.id} lacks required role`,
+ * }, (envelope) => {
+ *   return envelope.context.user?.roles?.includes("admin") ?? false;
+ * });
+ * ```
+ *
+ * @example Throwing custom GuardError for full control
+ * ```typescript
+ * const roleGuard = createGuard({ name: "role-guard" }, (envelope) => {
+ *   const userRoles = envelope.context.user?.roles ?? [];
+ *   const required = ["admin", "moderator"];
+ *   if (!required.some(r => userRoles.includes(r))) {
+ *     throw GuardError.role(required);
+ *   }
+ *   return true;
+ * });
+ * ```
+ */
+export declare function createGuard(fn: GuardFn): Middleware;
+export declare function createGuard(config: GuardConfig, fn: GuardFn): Middleware;
+//# sourceMappingURL=guard.d.ts.map

package/dist/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../src/guard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGjE;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,QAAQ,EAAE,iBAAiB,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEzF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,2DAA2D;IAC3D,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,iBAAiB,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,CAAC,CAAC;IAEnE,yEAAyE;IACzE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,OAAO,GAAG,UAAU,CAAC;AACrD,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,GAAG,UAAU,CAAC"}

package/dist/guard.js

@@ -0,0 +1,15 @@
+import { GuardError } from "@agentick/shared";
+export function createGuard(configOrFn, maybeFn) {
+    const config = typeof configOrFn === "function" ? {} : configOrFn;
+    const fn = typeof configOrFn === "function" ? configOrFn : maybeFn;
+    return async (args, envelope, next) => {
+        if (!(await fn(envelope))) {
+            const reason = typeof config.reason === "function"
+                ? config.reason(envelope)
+                : (config.reason ?? "Guard check failed");
+            throw new GuardError(reason, config.guardType ?? "custom", config.name ? { guard: config.name } : {});
+        }
+        return next();
+    };
+}
+//# sourceMappingURL=guard.js.map

package/dist/guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.js","sourceRoot":"","sources":["../src/guard.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAqE9C,MAAM,UAAU,WAAW,CAAC,UAAiC,EAAE,OAAiB;IAC9E,MAAM,MAAM,GAAgB,OAAO,UAAU,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC;IAC/E,MAAM,EAAE,GAAY,OAAO,UAAU,KAAK,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,OAAQ,CAAC;IAE7E,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE;QACpC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC;YAC1B,MAAM,MAAM,GACV,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU;gBACjC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;gBACzB,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,IAAI,oBAAoB,CAAC,CAAC;YAC9C,MAAM,IAAI,UAAU,CAClB,MAAM,EACN,MAAM,CAAC,SAAS,IAAI,QAAQ,EAC5B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAC1C,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+/**
+ * # Agentick Kernel
+ *
+ * Low-level execution primitives for the Agentick framework. The kernel provides
+ * the foundational infrastructure that all other Agentick packages build upon.
+ *
+ * ## Core Primitives
+ *
+ * - **Procedures** - Async function wrappers with middleware, context, and telemetry
+ * - **Context** - Request-scoped state with automatic propagation
+ * - **Channels** - Async generators for streaming with backpressure
+ * - **Telemetry** - Execution tracking, spans, and metrics
+ * - **Logger** - Structured logging with configurable levels
+ *
+ * ## When to Use Kernel Directly
+ *
+ * Most applications should use the higher-level `agentick` package. Use kernel directly when:
+ *
+ * - Building custom execution infrastructure
+ * - Creating new Agentick adapters or integrations
+ * - Need fine-grained control over procedure execution
+ *
+ * ## Example
+ *
+ * ```typescript
+ * import { createProcedure, Context } from './core';
+ *
+ * const myProcedure = createProcedure(
+ *   { name: 'my-operation' },
+ *   async (input: string) => {
+ *     return { result: input.toUpperCase() };
+ *   }
+ * );
+ *
+ * const result = await myProcedure.exec('hello');
+ * ```
+ *
+ * @see {@link Procedure} - The core procedure abstraction
+ * @see {@link KernelContext} - Request-scoped context
+ * @see {@link Channel} - Streaming primitive
+ * @see {@link Telemetry} - Execution tracking
+ *
+ * @module @agentick/kernel
+ */
+export * from "./context";
+export * from "./telemetry";
+export * from "./otel-provider";
+export * from "./procedure-graph";
+export * from "./execution-tracker";
+export * from "./execution-helpers";
+export * from "./metrics-helpers";
+export * from "./stream";
+export * from "./channel";
+export * from "./channel-helpers";
+export * from "./procedure";
+export * from "./logger";
+export * from "./event-buffer";
+export * from "./schema";
+export * from "./guard";
+export { GuardError, isGuardError } from "@agentick/shared";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,62 @@
+/**
+ * # Agentick Kernel
+ *
+ * Low-level execution primitives for the Agentick framework. The kernel provides
+ * the foundational infrastructure that all other Agentick packages build upon.
+ *
+ * ## Core Primitives
+ *
+ * - **Procedures** - Async function wrappers with middleware, context, and telemetry
+ * - **Context** - Request-scoped state with automatic propagation
+ * - **Channels** - Async generators for streaming with backpressure
+ * - **Telemetry** - Execution tracking, spans, and metrics
+ * - **Logger** - Structured logging with configurable levels
+ *
+ * ## When to Use Kernel Directly
+ *
+ * Most applications should use the higher-level `agentick` package. Use kernel directly when:
+ *
+ * - Building custom execution infrastructure
+ * - Creating new Agentick adapters or integrations
+ * - Need fine-grained control over procedure execution
+ *
+ * ## Example
+ *
+ * ```typescript
+ * import { createProcedure, Context } from './core';
+ *
+ * const myProcedure = createProcedure(
+ *   { name: 'my-operation' },
+ *   async (input: string) => {
+ *     return { result: input.toUpperCase() };
+ *   }
+ * );
+ *
+ * const result = await myProcedure.exec('hello');
+ * ```
+ *
+ * @see {@link Procedure} - The core procedure abstraction
+ * @see {@link KernelContext} - Request-scoped context
+ * @see {@link Channel} - Streaming primitive
+ * @see {@link Telemetry} - Execution tracking
+ *
+ * @module @agentick/kernel
+ */
+export * from "./context";
+export * from "./telemetry";
+export * from "./otel-provider";
+export * from "./procedure-graph";
+export * from "./execution-tracker";
+export * from "./execution-helpers";
+export * from "./metrics-helpers";
+export * from "./stream";
+export * from "./channel";
+export * from "./channel-helpers";
+export * from "./procedure";
+export * from "./logger";
+export * from "./event-buffer";
+export * from "./schema";
+export * from "./guard";
+// Re-export guard errors from shared (guards are a procedure concept)
+export { GuardError, isGuardError } from "@agentick/shared";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AAExB,sEAAsE;AACtE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/logger.d.ts

@@ -0,0 +1,341 @@
+/**
+ * Logger - Structured logging with automatic context injection
+ *
+ * Built on pino for performance, with automatic injection of:
+ * - Execution context (executionId, threadId, userId, tick)
+ * - OpenTelemetry trace/span IDs for log-trace correlation
+ * - Custom metadata
+ *
+ * @example
+ * ```typescript
+ * import { Logger } from './core';
+ *
+ * // Configure once at app start
+ * Logger.configure({
+ *   level: 'info',
+ *   transport: {
+ *     targets: [
+ *       { target: 'pino-pretty', options: { colorize: true } },
+ *       { target: 'pino/file', options: { destination: './app.log' } },
+ *     ],
+ *   },
+ * });
+ *
+ * // Use anywhere - context is auto-injected
+ * const log = Logger.get();
+ * log.info('Processing request');
+ *
+ * // Create scoped child logger
+ * const toolLog = Logger.for('CalculatorTool');
+ * toolLog.debug('Executing', { expression: '2+2' });
+ * ```
+ */
+import { type Logger as PinoLogger, type TransportSingleOptions, type TransportMultiOptions } from "pino";
+import { type KernelContext } from "./context";
+/**
+ * Log levels supported by the kernel logger.
+ *
+ * Levels in order of severity (least to most):
+ * - `trace` - Very detailed debugging information
+ * - `debug` - Debugging information
+ * - `info` - Normal operational messages
+ * - `warn` - Warning conditions
+ * - `error` - Error conditions
+ * - `fatal` - Severe errors causing shutdown
+ * - `silent` - Disable all logging
+ *
+ * @example
+ * ```typescript
+ * Logger.configure({ level: 'debug' });
+ * Logger.setLevel('warn'); // Runtime change
+ * if (Logger.isLevelEnabled('trace')) {
+ *   // Expensive debug operation
+ * }
+ * ```
+ */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal" | "silent";
+/**
+ * Function to extract fields from KernelContext for logging.
+ * Return an object with fields to include in every log entry.
+ *
+ * @typeParam TContext - The context type (extends KernelContext)
+ *
+ * @example
+ * ```typescript
+ * const myExtractor: ContextFieldsExtractor = (ctx) => ({
+ *   userId: ctx.user?.id,
+ *   tenantId: ctx.user?.tenantId,
+ *   requestId: ctx.requestId,
+ * });
+ * ```
+ *
+ * @see {@link composeContextFields} - Combine multiple extractors
+ */
+export type ContextFieldsExtractor<TContext extends KernelContext = KernelContext> = (ctx: TContext) => Record<string, unknown>;
+export interface LoggerConfig<TContext extends KernelContext = KernelContext> {
+    /** Log level (default: 'info') */
+    level?: LogLevel;
+    /** Pino transport configuration */
+    transport?: TransportSingleOptions | TransportMultiOptions;
+    /** Auto-inject execution context into every log (default: true) */
+    includeContext?: boolean;
+    /**
+     * Custom function to extract fields from context.
+     * If not provided, only core KernelContext fields are extracted.
+     * Use this to add application-specific fields from user/metadata.
+     *
+     * @example
+     * ```typescript
+     * Logger.configure({
+     *   contextFields: (ctx) => ({
+     *     // Core fields (you control what's included)
+     *     request_id: ctx.requestId,
+     *     trace_id: ctx.traceId,
+     *     // Your custom fields
+     *     tenantId: ctx.user?.tenantId,
+     *     threadId: ctx.metadata?.threadId,
+     *   }),
+     * });
+     * ```
+     */
+    contextFields?: ContextFieldsExtractor<TContext>;
+    /** Base properties to include in every log */
+    base?: Record<string, unknown>;
+    /** Custom mixin function for additional properties */
+    mixin?: () => Record<string, unknown>;
+    /** Pretty print in development (default: true if NODE_ENV !== 'production') */
+    prettyPrint?: boolean;
+    /**
+     * Replace existing config instead of merging (default: false).
+     * When true, completely replaces the existing configuration.
+     * When false (default), merges with existing configuration.
+     */
+    replace?: boolean;
+}
+/**
+ * Log method signature supporting both message-first and object-first forms.
+ *
+ * @example Message-first (simple logging)
+ * ```typescript
+ * log.info('User logged in');
+ * log.info('Processed %d items', count);
+ * ```
+ *
+ * @example Object-first (structured logging)
+ * ```typescript
+ * log.info({ userId, action: 'login' }, 'User logged in');
+ * log.error({ err, requestId }, 'Request failed');
+ * ```
+ */
+export interface LogMethod {
+    /** Log a message with optional printf-style args */
+    (msg: string, ...args: unknown[]): void;
+    /** Log structured data with optional message */
+    (obj: Record<string, unknown>, msg?: string, ...args: unknown[]): void;
+}
+/**
+ * Kernel logger interface with structured logging and context injection.
+ *
+ * Loggers automatically inject execution context (requestId, traceId, etc.)
+ * from the current `KernelContext` via AsyncLocalStorage.
+ *
+ * @example
+ * ```typescript
+ * const log = Logger.get();
+ *
+ * // Simple message
+ * log.info('Request received');
+ *
+ * // With structured data
+ * log.debug({ userId, action }, 'Processing action');
+ *
+ * // Create child logger with bindings
+ * const reqLog = log.child({ requestId: 'abc-123' });
+ *
+ * // Check level before expensive operation
+ * if (log.isLevelEnabled('trace')) {
+ *   log.trace({ fullState: getState() }, 'State dump');
+ * }
+ * ```
+ *
+ * @see {@link Logger} - Static methods to get/configure loggers
+ * @see {@link LogLevel} - Available log levels
+ */
+export interface KernelLogger {
+    /** Log at trace level (very detailed debugging) */
+    trace: LogMethod;
+    /** Log at debug level (debugging information) */
+    debug: LogMethod;
+    /** Log at info level (normal operations) */
+    info: LogMethod;
+    /** Log at warn level (warning conditions) */
+    warn: LogMethod;
+    /** Log at error level (error conditions) */
+    error: LogMethod;
+    /** Log at fatal level (severe errors) */
+    fatal: LogMethod;
+    /** Create a child logger with additional bindings */
+    child(bindings: Record<string, unknown>): KernelLogger;
+    /** Get the current log level */
+    level: LogLevel;
+    /** Check if a level is enabled */
+    isLevelEnabled(level: LogLevel): boolean;
+}
+/**
+ * Logger singleton for Agentick applications.
+ *
+ * Provides structured logging with automatic context injection from the
+ * current execution context (via AsyncLocalStorage).
+ *
+ * @example
+ * ```typescript
+ * // Configure at app startup
+ * Logger.configure({ level: 'debug' });
+ *
+ * // Get logger (context auto-injected)
+ * const log = Logger.get();
+ * log.info('Request received');
+ *
+ * // Create child logger for a component
+ * const componentLog = Logger.for('MyComponent');
+ * componentLog.debug('Initializing');
+ *
+ * // Or from an object (uses constructor name)
+ * class MyTool {
+ *   private log = Logger.for(this);
+ * }
+ * ```
+ */
+export declare const Logger: {
+    /**
+     * Configure the global logger.
+     * Should be called once at application startup.
+     *
+     * @param config Logger configuration
+     *
+     * @example
+     * ```typescript
+     * Logger.configure({
+     *   level: process.env.LOG_LEVEL ?? 'info',
+     *   transport: {
+     *     targets: [
+     *       { target: 'pino-pretty', options: { colorize: true } },
+     *       { target: 'pino/file', options: { destination: './logs/app.log' } },
+     *     ],
+     *   },
+     * });
+     * ```
+     */
+    configure(config: LoggerConfig): void;
+    /**
+     * Get the global logger instance.
+     * Context is automatically injected into every log.
+     *
+     * @returns KernelLogger instance
+     *
+     * @example
+     * ```typescript
+     * const log = Logger.get();
+     * log.info('Processing', { items: 5 });
+     * // Output includes executionId, userId, trace_id, etc.
+     * ```
+     */
+    get(): KernelLogger;
+    /**
+     * Create a child logger scoped to a component or name.
+     *
+     * @param nameOrComponent Component name or object (uses constructor.name)
+     * @returns Child logger with component binding
+     *
+     * @example
+     * ```typescript
+     * // With string name
+     * const log = Logger.for('CalculatorTool');
+     *
+     * // With object (uses class name)
+     * class MyAgent {
+     *   private log = Logger.for(this);
+     * }
+     * ```
+     */
+    for(nameOrComponent: string | object): KernelLogger;
+    /**
+     * Create a child logger with custom bindings.
+     *
+     * @param bindings Key-value pairs to include in every log
+     * @returns Child logger with bindings
+     *
+     * @example
+     * ```typescript
+     * const requestLog = Logger.child({ request_id: req.id });
+     * requestLog.info('Handling request');
+     * ```
+     */
+    child(bindings: Record<string, unknown>): KernelLogger;
+    /**
+     * Create a standalone logger instance with custom config.
+     * Does not affect the global logger.
+     *
+     * @param config Logger configuration
+     * @returns New logger instance
+     *
+     * @example
+     * ```typescript
+     * const auditLog = Logger.create({
+     *   level: 'info',
+     *   transport: { target: 'pino/file', options: { destination: './audit.log' } },
+     * });
+     * ```
+     */
+    create(config?: LoggerConfig): KernelLogger;
+    /**
+     * Get the current log level.
+     */
+    readonly level: LogLevel;
+    /**
+     * Set the log level at runtime.
+     *
+     * @param level New log level
+     */
+    setLevel(level: LogLevel): void;
+    /**
+     * Check if a level is enabled.
+     *
+     * @param level Log level to check
+     * @returns true if the level is enabled
+     */
+    isLevelEnabled(level: LogLevel): boolean;
+    /**
+     * Reset the global logger (mainly for testing).
+     */
+    reset(): void;
+};
+/**
+ * Compose multiple context field extractors into one.
+ * Later extractors override earlier ones for the same keys.
+ *
+ * @example
+ * ```typescript
+ * import { composeContextFields, defaultContextFields } from './core';
+ *
+ * Logger.configure({
+ *   contextFields: composeContextFields(
+ *     defaultContextFields,  // Core kernel fields
+ *     (ctx) => ({            // Your custom fields
+ *       tenantId: ctx.user?.tenantId,
+ *       threadId: ctx.metadata?.threadId,
+ *       executionId: ctx.metadata?.executionId,
+ *     }),
+ *   ),
+ * });
+ * ```
+ */
+export declare function composeContextFields(...extractors: ContextFieldsExtractor[]): ContextFieldsExtractor;
+/**
+ * The default context fields extractor.
+ * Exports core KernelContext fields only.
+ * Use with composeContextFields to extend.
+ */
+export declare const defaultContextFields: ContextFieldsExtractor<KernelContext>;
+export type { PinoLogger, TransportSingleOptions, TransportMultiOptions };
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"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"}