@loutrejs/loutre 0.9.2 → 0.10.1

package/dist/runtime/logger.d.ts

@@ -1,38 +1,2 @@
-import { frameworkProvidedTokenBrand } from '../core/token-internal.js';
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export interface LogRecord {
-    readonly timestamp: string;
-    readonly level: LogLevel;
-    readonly message: string;
-    readonly [key: string]: unknown;
-}
-export interface LoggerBackend {
-    write(record: LogRecord): void;
-}
-export interface ConsoleLoggerBackendOptions {
-    readonly colors?: boolean;
-    readonly prefix?: string;
-}
-export declare class ConsoleLoggerBackend implements LoggerBackend {
-    #private;
-    constructor(options?: ConsoleLoggerBackendOptions);
-    write(record: LogRecord): void;
-}
-export declare class JsonConsoleLoggerBackend implements LoggerBackend {
-    write(record: LogRecord): void;
-}
-export declare class Logger {
-    #private;
-    readonly backend: LoggerBackend;
-    readonly context: Readonly<Record<string, unknown>>;
-    static readonly [frameworkProvidedTokenBrand] = true;
-    constructor(backend?: LoggerBackend, context?: Readonly<Record<string, unknown>>);
-    child(context: Readonly<Record<string, unknown>>): Logger;
-    debug(message: string, context?: Readonly<Record<string, unknown>>): void;
-    info(message: string, context?: Readonly<Record<string, unknown>>): void;
-    warn(message: string, context?: Readonly<Record<string, unknown>>): void;
-    error(message: string, context?: Readonly<Record<string, unknown>>): void;
-}
-export declare class SilentLogger extends Logger {
-    constructor(context?: Readonly<Record<string, unknown>>);
-}
+export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, LoggerService, LoggerToken, SilentLogger, } from '../core/logger.js';
+export type { ConsoleLoggerBackendOptions, LoggerBackend, LogLevel, LogRecord, } from '../core/logger.js';

package/dist/runtime/logger.js

@@ -1,209 +1 @@
-import { frameworkProvidedTokenBrand } from '../core/token-internal.js';
-export class ConsoleLoggerBackend {
-    #colors;
-    #prefix;
-    constructor(options = {}) {
-        this.#colors = options.colors ?? detectConsoleColors();
-        this.#prefix = options.prefix ?? 'Loutre';
-    }
-    write(record) {
-        writeToConsole(record.level, formatConsoleLogRecord(record, this.#prefix, this.#colors));
-    }
-}
-export class JsonConsoleLoggerBackend {
-    write(record) {
-        writeToConsole(record.level, serializeLogRecord(record));
-    }
-}
-class SilentLoggerBackend {
-    write(_record) { }
-}
-export class Logger {
-    backend;
-    context;
-    static [frameworkProvidedTokenBrand] = true;
-    constructor(backend = new ConsoleLoggerBackend(), context = {}) {
-        this.backend = backend;
-        this.context = context;
-    }
-    child(context) {
-        return new Logger(this.backend, { ...this.context, ...context });
-    }
-    debug(message, context = {}) {
-        this.#write('debug', message, context);
-    }
-    info(message, context = {}) {
-        this.#write('info', message, context);
-    }
-    warn(message, context = {}) {
-        this.#write('warn', message, context);
-    }
-    error(message, context = {}) {
-        this.#write('error', message, context);
-    }
-    #write(level, message, context) {
-        this.backend.write({
-            ...this.context,
-            ...context,
-            timestamp: new Date().toISOString(),
-            level,
-            message,
-        });
-    }
-}
-export class SilentLogger extends Logger {
-    constructor(context = {}) {
-        super(new SilentLoggerBackend(), context);
-    }
-}
-function serializeLogRecord(record) {
-    const seen = new WeakSet();
-    try {
-        return JSON.stringify(record, (_key, value) => {
-            if (typeof value === 'bigint')
-                return value.toString();
-            if (value instanceof Error) {
-                return {
-                    name: value.name,
-                    message: value.message,
-                    ...(value.stack === undefined ? {} : { stack: value.stack }),
-                    ...(value.cause === undefined ? {} : { cause: value.cause }),
-                };
-            }
-            if (value !== null && typeof value === 'object') {
-                if (seen.has(value))
-                    return '[Circular]';
-                seen.add(value);
-            }
-            return value;
-        });
-    }
-    catch (error) {
-        return JSON.stringify({
-            timestamp: record.timestamp,
-            level: 'error',
-            message: 'Log record serialization failed',
-            serializationError: error instanceof Error ? error.message : String(error),
-        });
-    }
-}
-function writeToConsole(level, value) {
-    const target = level === 'error'
-        ? console.error
-        : level === 'warn'
-            ? console.warn
-            : console.log;
-    target(value);
-}
-function formatConsoleLogRecord(record, prefix, colors) {
-    const { timestamp, level, message, ...recordContext } = record;
-    const context = { ...recordContext };
-    const source = typeof context.source === 'string'
-        ? context.source
-        : typeof context.protocol === 'string'
-            ? context.protocol
-            : undefined;
-    if (source !== undefined)
-        delete context.source;
-    const runtimeProcess = getRuntimeProcess();
-    const processLabel = runtimeProcess?.pid === undefined
-        ? `[${prefix}]`
-        : `[${prefix}] ${runtimeProcess.pid}`;
-    const levelLabel = level === 'info' ? 'LOG' : level.toUpperCase();
-    const levelColor = level === 'error' ? 31 : level === 'warn' ? 33 : level === 'debug' ? 36 : 32;
-    const sourceLabel = source === undefined ? '' : `${paint(`[${source}]`, 33, colors)} `;
-    const formattedContext = formatLogContext(context);
-    const contextSuffix = formattedContext === '' ? '' : ` ${paint(formattedContext, 90, colors)}`;
-    return `${paint(processLabel, 32, colors)}  - ${formatLocalTimestamp(timestamp)}  ${paint(levelLabel.padStart(7), levelColor, colors)} ${sourceLabel}${paint(message, levelColor, colors)}${contextSuffix}`;
-}
-function formatLogContext(context) {
-    const entries = Object.entries(context);
-    if (entries.length === 0)
-        return '';
-    return `{ ${entries
-        .map(([key, value]) => `${formatLogKey(key)}=${formatLogValue(value)}`)
-        .join(', ')} }`;
-}
-function formatLogKey(key) {
-    return /^[A-Za-z_$][\w$]*$/u.test(key) ? key : JSON.stringify(key);
-}
-function formatLogValue(value, ancestors = new WeakSet()) {
-    try {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (typeof value === 'string') {
-            return /^[\w./:@+-]+$/u.test(value) ? value : JSON.stringify(value);
-        }
-        if (typeof value === 'number' || typeof value === 'boolean')
-            return String(value);
-        if (typeof value === 'bigint')
-            return `${value}n`;
-        if (typeof value === 'symbol')
-            return String(value);
-        if (typeof value === 'function')
-            return `[Function ${value.name || 'anonymous'}]`;
-        if (ancestors.has(value))
-            return '[Circular]';
-        ancestors.add(value);
-        try {
-            if (value instanceof Date)
-                return value.toISOString();
-            if (value instanceof Error) {
-                return formatLogValue({
-                    name: value.name,
-                    message: value.message,
-                    ...(value.stack === undefined ? {} : { stack: value.stack }),
-                    ...(value.cause === undefined ? {} : { cause: value.cause }),
-                }, ancestors);
-            }
-            if (Array.isArray(value)) {
-                return `[${value.map((item) => formatLogValue(item, ancestors)).join(', ')}]`;
-            }
-            return `{ ${Object.entries(value)
-                .map(([key, item]) => `${formatLogKey(key)}=${formatLogValue(item, ancestors)}`)
-                .join(', ')} }`;
-        }
-        finally {
-            ancestors.delete(value);
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return `[Unformattable: ${message}]`;
-    }
-}
-function formatLocalTimestamp(timestamp) {
-    const date = new Date(timestamp);
-    if (Number.isNaN(date.getTime()))
-        return timestamp;
-    return ([
-        date.getFullYear(),
-        String(date.getMonth() + 1).padStart(2, '0'),
-        String(date.getDate()).padStart(2, '0'),
-    ].join('/') +
-        ` ${[
-            String(date.getHours()).padStart(2, '0'),
-            String(date.getMinutes()).padStart(2, '0'),
-            String(date.getSeconds()).padStart(2, '0'),
-        ].join(':')}.${String(date.getMilliseconds()).padStart(3, '0')}`);
-}
-function paint(value, color, enabled) {
-    return enabled ? `\u001B[${color}m${value}\u001B[39m` : value;
-}
-function getRuntimeProcess() {
-    return globalThis.process;
-}
-function detectConsoleColors() {
-    const runtimeProcess = getRuntimeProcess();
-    const environment = runtimeProcess?.env;
-    if (environment?.NO_COLOR !== undefined ||
-        environment?.NODE_DISABLE_COLORS !== undefined) {
-        return false;
-    }
-    if (environment?.FORCE_COLOR !== undefined) {
-        return environment.FORCE_COLOR !== '0';
-    }
-    return runtimeProcess?.stdout?.isTTY === true;
-}
+export { ConsoleLoggerBackend, JsonConsoleLoggerBackend, LoggerService, LoggerToken, SilentLogger, } from '../core/logger.js';

package/dist/runtime/node-capabilities.d.ts

@@ -1,5 +1,5 @@
 /** CLIが`@loutrejs/node`へ依存するとBunでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
 export declare const nodeRuntimeSupport: {
     readonly runtime: 'node';
-    readonly capabilities: Set<string>;
+    readonly capabilities: ReadonlySet<import("./capability.js").RuntimeSupportFeature>;
 };

package/dist/runtime/node-capabilities.js

@@ -1,7 +1,8 @@
+import { runtimeSupportFeatures } from './capability.js';
 /** CLIが`@loutrejs/node`へ依存するとBunでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
 export const nodeRuntimeSupport = {
     runtime: 'node',
-    capabilities: new Set([
+    capabilities: runtimeSupportFeatures([
         'http.server',
         'websocket.server',
         'http.request.streaming',

package/dist/runtime/server-port.d.ts

@@ -1,2 +1,6 @@
-export declare function initialServerPort(requestedPort: number | undefined): number;
+import type { Brand } from '../internal/brand.js';
+export type RequestedPort = Brand<number, 'port.requested'>;
+export type BoundPort = Brand<number, 'port.bound'>;
+export declare const boundPort: (value: number) => BoundPort;
+export declare function initialServerPort(requestedPort: number | undefined): RequestedPort;
 export declare function canRetryOnNextPort(error: unknown, port: number): boolean;

package/dist/runtime/server-port.js

@@ -1,5 +1,6 @@
+export const boundPort = (value) => value;
 export function initialServerPort(requestedPort) {
-    return requestedPort ?? 3000;
+    return (requestedPort ?? 3000);
 }
 export function canRetryOnNextPort(error, port) {
     return port < 65_535 && isAddressInUseError(error);

package/dist/runtime/shutdown-hooks.d.ts

@@ -6,7 +6,7 @@ export interface ProcessSignalSource {
 export interface ProcessShutdownHooksOptions {
     readonly source: ProcessSignalSource;
     readonly close: (signal: ShutdownSignal) => Promise<void>;
-    readonly onError: (error: unknown, signal: ShutdownSignal) => void;
+    readonly onError: (error: unknown, signal: ShutdownSignal) => void | Promise<void>;
 }
 export declare class ProcessShutdownHooks {
     #private;

package/dist/runtime/shutdown-hooks.js

@@ -43,7 +43,8 @@ export class ProcessShutdownHooks {
                 return;
             }
             catch (error) {
-                this.#reportError(error, signal);
+                // ログ送信の完了待ちでshutdownの再試行を止めない。
+                void this.#reportError(error, signal);
                 if (!(error instanceof ApplicationShutdownError) ||
                     error.safeCleanupBoundaryReached ||
                     !error.retryAfter)
@@ -52,15 +53,15 @@ export class ProcessShutdownHooks {
                     await error.retryAfter;
                 }
                 catch (retryError) {
-                    this.#reportError(retryError, signal);
+                    void this.#reportError(retryError, signal);
                     return;
                 }
             }
         }
     }
-    #reportError(error, signal) {
+    async #reportError(error, signal) {
         try {
-            this.#options.onError(error, signal);
+            await this.#options.onError(error, signal);
         }
         catch (reportingError) {
             console.error('Runtime shutdown error reporter failed', error, reportingError);

package/dist/tasks/extension.d.ts

@@ -1,3 +1,5 @@
+import { type DurationMs } from '../core/units.js';
+import { type TaskExecutionKey, type TaskName, type TriggerName, type QueueName } from './identity.js';
 import { type ExecutionDefinition, type ProviderDescriptor, type SchemaOutput, type StandardSchemaV1, type Token } from '../core/index.js';
 export type TaskRuntime<TInput, TOutput> = [TInput] extends [void] ? () => TOutput | Promise<TOutput> : (input: TInput) => TOutput | Promise<TOutput>;
 export interface TaskDefinitionData<TInput = unknown, TOutput = unknown> {
@@ -13,7 +15,7 @@ export type TaskArguments<TTask> = [TaskInput<TTask>] extends [void] ? readonly
 declare const taskExecutionIdentityKey: unique symbol;
 declare const queueDriverToken: unique symbol;
 export interface TaskExecutionIdentity {
-    readonly [taskExecutionIdentityKey]: symbol;
+    readonly [taskExecutionIdentityKey]: TaskExecutionKey;
 }
 type AnyTaskDefinition = ExecutionDefinition & TaskExecutionIdentity & {
     readonly type: 'task';
@@ -39,7 +41,7 @@ export interface FixedDelayTriggerDefinitionData<TTask extends AnyTaskDefinition
 }
 export interface QueueDescriptor<TSchema extends StandardSchemaV1 = StandardSchemaV1, TName extends string = string> {
     readonly kind: 'queue';
-    readonly name: TName;
+    readonly name: QueueName<TName>;
     readonly payload: TSchema;
     readonly [queueDriverToken]: Token<QueueConsumerDriver>;
 }
@@ -62,39 +64,39 @@ export type TriggerDefinitionData = CronTriggerDefinitionData | FixedDelayTrigge
 type TasksDefinitionData = (TaskDefinitionData & TaskExecutionIdentity) | TriggerDefinitionData;
 export interface TasksCompiledTask {
     readonly type: 'task';
-    readonly taskExecutionId: symbol;
-    readonly name: string;
+    readonly taskExecutionId: TaskExecutionKey;
+    readonly name: TaskName;
     readonly factory: () => (...arguments_: any[]) => any;
 }
 export interface TasksCompiledCronTrigger {
     readonly type: 'cron';
-    readonly name: string;
+    readonly name: TriggerName;
     readonly expression: string;
     readonly timezone: string;
     readonly overlap: CronOverlap;
-    readonly taskExecutionId: symbol;
-    readonly taskName: string;
+    readonly taskExecutionId: TaskExecutionKey;
+    readonly taskName: TaskName;
 }
 export interface TasksCompiledFixedDelayTrigger {
     readonly type: 'fixed-delay';
-    readonly name: string;
-    readonly delay: number;
+    readonly name: TriggerName;
+    readonly delay: DurationMs;
     readonly immediate: boolean;
-    readonly taskExecutionId: symbol;
-    readonly taskName: string;
+    readonly taskExecutionId: TaskExecutionKey;
+    readonly taskName: TaskName;
 }
 export interface TasksCompiledQueueConsumerTrigger {
     readonly type: 'queue-consumer';
-    readonly name: string;
-    readonly queueName: string;
+    readonly name: TriggerName;
+    readonly queueName: QueueName;
     readonly queuePayload: StandardSchemaV1;
     readonly queueDriver: Token<QueueConsumerDriver>;
-    readonly taskExecutionId: symbol;
-    readonly taskName: string;
+    readonly taskExecutionId: TaskExecutionKey;
+    readonly taskName: TaskName;
 }
 export type TasksCompiledExecution = TasksCompiledTask | TasksCompiledCronTrigger | TasksCompiledFixedDelayTrigger | TasksCompiledQueueConsumerTrigger;
 export interface TasksExtensionRuntime {
-    run<TInput, TOutput>(taskExecutionId: symbol, taskName: string, ...arguments_: [TInput] extends [void] ? readonly [] : readonly [input: TInput]): Promise<TOutput>;
+    run<TInput, TOutput>(taskExecutionId: TaskExecutionKey, taskName: string, ...arguments_: [TInput] extends [void] ? readonly [] : readonly [input: TInput]): Promise<TOutput>;
     startTriggers(): Promise<void>;
     stopTriggers(): Promise<void>;
     drain(): Promise<void>;

package/dist/tasks/extension.js

@@ -1,5 +1,8 @@
+import { dependencyConsumerId } from '../core/identity.js';
+import { milliseconds } from '../core/units.js';
+import { taskExecutionKey, taskName as compiledTaskName, triggerName, queueName, } from './identity.js';
 import { collectInjectedDependencies, defineExecution, defineExecutionExtension, provide, runInInjectionContext, token, validateSchema, } from '../core/index.js';
-import { isValidCronExpression, matchesCronTrigger } from './runtime/cron.js';
+import { isValidCronExpression, matchesCronTrigger, parseCronSchedule, } from './runtime/cron.js';
 import { match } from 'ts-pattern';
 const taskExecutionIdentityKey = Symbol.for('loutre.tasks.task-execution-identity');
 const queueDriverToken = Symbol.for('loutre.tasks.queue-driver');
@@ -15,14 +18,14 @@ export const tasksExtension = defineExecutionExtension({
             executionKind: 'task.invocation',
             dependencies: collectInjectedDependencies({
                 kind: 'execution',
-                id: `task:${candidate.name}`,
-                name: candidate.name,
+                id: dependencyConsumerId(`task:${candidate.name}`),
+                name: compiledTaskName(candidate.name),
             }, () => candidate.factory()),
             capabilities: [],
             compiled: Object.freeze({
                 type: 'task',
                 taskExecutionId: candidate[taskExecutionIdentityKey],
-                name: candidate.name,
+                name: compiledTaskName(candidate.name),
                 factory: candidate.factory,
             }),
         }))
@@ -34,12 +37,12 @@ export const tasksExtension = defineExecutionExtension({
             capabilities: [],
             compiled: Object.freeze({
                 type: 'cron',
-                name: candidate.name,
+                name: triggerName(candidate.name),
                 expression: candidate.expression,
                 timezone: candidate.timezone,
                 overlap: candidate.overlap,
                 taskExecutionId: candidate.task[taskExecutionIdentityKey],
-                taskName: candidate.task.name,
+                taskName: compiledTaskName(candidate.task.name),
             }),
         }))
             .with({ type: 'fixed-delay' }, (candidate) => ({
@@ -50,11 +53,11 @@ export const tasksExtension = defineExecutionExtension({
             capabilities: [],
             compiled: Object.freeze({
                 type: 'fixed-delay',
-                name: candidate.name,
-                delay: candidate.delay,
+                name: triggerName(candidate.name),
+                delay: milliseconds(candidate.delay),
                 immediate: candidate.immediate,
                 taskExecutionId: candidate.task[taskExecutionIdentityKey],
-                taskName: candidate.task.name,
+                taskName: compiledTaskName(candidate.task.name),
             }),
         }))
             .with({ type: 'queue-consumer' }, (candidate) => ({
@@ -65,12 +68,12 @@ export const tasksExtension = defineExecutionExtension({
             capabilities: [],
             compiled: Object.freeze({
                 type: 'queue-consumer',
-                name: candidate.name,
+                name: triggerName(candidate.name),
                 queueName: candidate.queue.name,
                 queuePayload: candidate.queue.payload,
                 queueDriver: queueRuntimeToken(candidate.queue),
                 taskExecutionId: candidate.task[taskExecutionIdentityKey],
-                taskName: candidate.task.name,
+                taskName: compiledTaskName(candidate.task.name),
             }),
         }))
             .exhaustive();
@@ -142,7 +145,7 @@ export const tasksExtension = defineExecutionExtension({
             .with({ type: 'fixed-delay' }, (candidate) => ({
             type: 'fixed-delay',
             name: candidate.name,
-            delay: candidate.delay,
+            delay: milliseconds(candidate.delay),
             immediate: candidate.immediate,
             task: candidate.taskName,
         }))
@@ -168,7 +171,7 @@ export const tasksExtension = defineExecutionExtension({
     },
 });
 export function task(definition) {
-    const taskExecutionId = Symbol(`loutre.tasks.execution:${definition.name}`);
+    const taskExecutionId = taskExecutionKey(Symbol(`loutre.tasks.execution:${definition.name}`));
     return defineExecution(tasksExtension, {
         type: 'task',
         name: definition.name,
@@ -209,7 +212,7 @@ export function queue(declaration) {
     }
     return Object.freeze({
         kind: 'queue',
-        name: declaration.name,
+        name: queueName(declaration.name),
         payload: declaration.payload,
         [queueDriverToken]: token(`loutre.tasks.queue-driver.${declaration.name}`),
     });
@@ -230,7 +233,6 @@ export function consume(declaration) {
 }
 function createTasksRuntime(bindings, applicationRuntime) {
     const runtimes = new Map();
-    const runtimeExecutionIds = new Map();
     const triggers = [];
     for (const { execution, resolve } of bindings) {
         const compiled = execution.compiled;
@@ -241,13 +243,15 @@ function createTasksRuntime(bindings, applicationRuntime) {
         const runtime = runInInjectionContext({
             consumer: {
                 kind: 'execution',
-                id: `task:${compiled.name}`,
+                id: dependencyConsumerId(`task:${compiled.name}`),
                 name: compiled.name,
             },
             resolve: (dependency, consumer) => resolve(dependency, { consumer }),
         }, () => compiled.factory());
-        runtimes.set(compiled.taskExecutionId, runtime);
-        runtimeExecutionIds.set(compiled.taskExecutionId, execution.id);
+        runtimes.set(compiled.taskExecutionId, {
+            invoke: runtime,
+            executionId: execution.id,
+        });
     }
     let triggerHandles = [];
     let triggerStartup;
@@ -264,7 +268,7 @@ function createTasksRuntime(bindings, applicationRuntime) {
             return Promise.reject(new Error(`LUTRE_TASK_NOT_REGISTERED: ${taskName}`));
         }
         const invocation = (async () => {
-            const executionId = runtimeExecutionIds.get(taskExecutionId) ?? taskName;
+            const executionId = runtime.executionId;
             const hasInput = arguments_.length > 0;
             const input = hasInput ? arguments_[0] : undefined;
             const lease = applicationRuntime.beginExecution({
@@ -279,7 +283,7 @@ function createTasksRuntime(bindings, applicationRuntime) {
             let result;
             let hasResult = false;
             try {
-                const invoke = () => Reflect.apply(runtime, undefined, arguments_);
+                const invoke = () => Reflect.apply(runtime.invoke, undefined, arguments_);
                 result = await (lease.run ? lease.run(invoke) : invoke());
                 hasResult = true;
                 return result;
@@ -416,13 +420,14 @@ async function startTrigger(trigger, run, resolve) {
 }
 function startCronTrigger(trigger, run) {
     let stopped = false;
+    const schedule = parseCronSchedule(trigger.expression, trigger.timezone);
     let lastMinute;
     const active = new Set();
     const tick = () => {
         if (stopped)
             return;
         const now = new Date();
-        if (!matchesCronTrigger(trigger, now))
+        if (!matchesCronTrigger(schedule, now))
             return;
         const minute = Math.floor(now.getTime() / 60_000);
         if (lastMinute === minute)
@@ -506,9 +511,9 @@ async function startQueueTrigger(trigger, run, resolve) {
 function taskExecutionIdentity(definition) {
     if (taskExecutionIdentityKey in definition &&
         typeof definition[taskExecutionIdentityKey] === 'symbol') {
-        return definition[taskExecutionIdentityKey];
+        return taskExecutionKey(definition[taskExecutionIdentityKey]);
     }
-    return Symbol('loutre.tasks.unregistered');
+    return taskExecutionKey(Symbol('loutre.tasks.unregistered'));
 }
 function tasksStateError(state) {
     return new Error(`LUTRE_TASKS_${state.toUpperCase()}`);

package/dist/tasks/identity.d.ts

@@ -0,0 +1,9 @@
+import type { Brand } from '../internal/brand.js';
+export type TaskExecutionKey = Brand<symbol, 'tasks.execution-key'>;
+export type TaskName = Brand<string, 'tasks.task-name'>;
+export type TriggerName = Brand<string, 'tasks.trigger-name'>;
+export type QueueName<TName extends string = string> = Brand<TName, 'tasks.queue-name'>;
+export declare const taskExecutionKey: (value: symbol) => TaskExecutionKey;
+export declare const taskName: (value: string) => TaskName;
+export declare const triggerName: (value: string) => TriggerName;
+export declare const queueName: <const TName extends string>(value: TName) => QueueName<TName>;

package/dist/tasks/identity.js

@@ -0,0 +1,4 @@
+export const taskExecutionKey = (value) => value;
+export const taskName = (value) => value;
+export const triggerName = (value) => value;
+export const queueName = (value) => value;

package/dist/tasks/index.d.ts

@@ -1,2 +1,3 @@
 export { bindQueueDriver, consume, cron, fixedDelay, queue, task, tasksExtension, } from './extension.js';
 export type { CronOverlap, CronTriggerDefinition, CronTriggerDefinitionData, FixedDelayTriggerDefinition, FixedDelayTriggerDefinitionData, QueueConsumerDriver, QueueConsumerHandle, QueueConsumerTriggerDefinition, QueueConsumerTriggerDefinitionData, QueueDescriptor, QueuePayload, TaskArguments, TaskDefinition, TaskDefinitionData, TaskExecutionIdentity, TaskInput, TaskOutput, TaskRuntime, TasksCompiledCronTrigger, TasksCompiledExecution, TasksCompiledFixedDelayTrigger, TasksCompiledQueueConsumerTrigger, TasksCompiledTask, TasksExtensionRuntime, TasksHostApi, TriggerDefinition, TriggerDefinitionData, } from './extension.js';
+export type { TaskExecutionKey, TaskName, TriggerName, QueueName, } from './identity.js';

package/dist/tasks/runtime/cron.d.ts

@@ -1,6 +1,10 @@
+import type { Brand } from '../../internal/brand.js';
+export type CronExpression = Brand<string, 'tasks.cron-expression'>;
+export type IanaTimeZone = Brand<string, 'tasks.iana-timezone'>;
 export interface CronSchedule {
-    readonly expression: string;
-    readonly timezone: string;
+    readonly expression: CronExpression;
+    readonly timezone: IanaTimeZone;
 }
 export declare function matchesCronTrigger(trigger: CronSchedule, instant: Date): boolean;
 export declare function isValidCronExpression(expression: string): boolean;
+export declare function parseCronSchedule(expression: string, timezone: string): CronSchedule;

package/dist/tasks/runtime/cron.js

@@ -87,3 +87,12 @@ function isValidCronField(field, minimum, maximum) {
         return start >= minimum && end <= maximum && start <= end;
     });
 }
+export function parseCronSchedule(expression, timezone) {
+    if (!isValidCronExpression(expression))
+        throw new TypeError('portableな5-field cron expressionが必要です。');
+    new Intl.DateTimeFormat('en-US', { timeZone: timezone }).format();
+    return Object.freeze({
+        expression: expression,
+        timezone: timezone,
+    });
+}