@yoyoboot/yoyo-admin-core 10.5.5

package/dist/contracts/mappers.js

@@ -0,0 +1,40 @@
+export function createEmptyApplicationConfiguration() {
+    return {
+        currentUser: {
+            id: "",
+            userName: "",
+            name: "未登录",
+            surname: "",
+            email: "",
+            title: "未初始化",
+            initials: "YA",
+            isAuthenticated: false,
+        },
+        currentTenant: {
+            id: "",
+            name: "Host Context",
+            plan: "Internal Preview",
+            environment: "Local Development",
+        },
+        identitySwitch: {
+            mode: "normal",
+            canReturn: false,
+        },
+        timing: {
+            timeZoneSettingId: "UTC",
+            timeZoneIana: "Etc/UTC",
+        },
+        grantedPolicies: {},
+        settings: {},
+        features: {},
+        localization: {},
+        modules: [],
+        themePreference: "system",
+    };
+}
+export function hasPermission(grantedPolicies, permission) {
+    return grantedPolicies[permission] === true;
+}
+export function listGrantedPolicies(grantedPolicies) {
+    return Object.keys(grantedPolicies).filter((permission) => grantedPolicies[permission] === true);
+}

package/dist/contracts/models.d.ts

@@ -0,0 +1,68 @@
+export type ThemePreference = "light" | "dark" | "system";
+export interface CurrentUser {
+    id: string;
+    userName: string;
+    name: string;
+    surname: string;
+    email: string;
+    title: string;
+    initials: string;
+    isAuthenticated: boolean;
+}
+export interface CurrentTenant {
+    id: string;
+    name: string;
+    tenancyName?: string;
+    plan: string;
+    environment: string;
+}
+export interface IdentitySwitchState {
+    mode: "normal" | "impersonated" | "delegated" | "linked";
+    sourceUserId?: string;
+    sourceTenantId?: string;
+    canReturn: boolean;
+}
+export interface ApplicationNavigationMetadata {
+    routeName: string;
+    pageKey: string;
+    menuKey: string;
+    title: string;
+    group: string;
+    permission?: string;
+    feature?: string;
+}
+export interface ApplicationModuleMetadata {
+    moduleKey: string;
+    permissions: string[];
+    features: string[];
+    navigation: ApplicationNavigationMetadata[];
+}
+export interface ManagedMenuConfiguration {
+    menuKey: string;
+    routeName: string;
+    pageKey: string;
+    parentMenuKey?: string;
+    title?: string;
+    description?: string;
+    group?: string;
+    subGroup?: string;
+    order?: number;
+    isEnabled: boolean;
+}
+export interface YoyoTemporalContext {
+    timeZoneSettingId: string;
+    timeZoneIana: string;
+}
+export interface ApplicationConfigurationState {
+    currentUser: CurrentUser;
+    currentTenant: CurrentTenant;
+    identitySwitch: IdentitySwitchState;
+    timing: YoyoTemporalContext;
+    grantedPolicies: Record<string, boolean>;
+    settings: Record<string, string>;
+    features: Record<string, unknown>;
+    localization: Record<string, unknown>;
+    modules?: ApplicationModuleMetadata[];
+    managedMenus?: ManagedMenuConfiguration[];
+    themePreference: ThemePreference;
+}

package/dist/contracts/models.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/page.d.ts

@@ -0,0 +1,28 @@
+export interface PageQueryInput {
+    page?: number;
+    pageSize?: number;
+    keyword?: string;
+    sorting?: string;
+}
+export interface PageQueryState {
+    page: number;
+    pageSize: number;
+    maxResultCount: number;
+    skipCount: number;
+    keyword?: string;
+    sorting?: string;
+}
+export interface PagedRequest {
+    skipCount: number;
+    maxResultCount: number;
+    sorting?: string;
+}
+export interface PageResult<TItem> extends PageQueryState {
+    items: TItem[];
+    totalCount: number;
+    pageCount: number;
+}
+export declare function createPageQueryState(input?: PageQueryInput): PageQueryState;
+export declare function createPagedRequest(input?: PageQueryInput): PagedRequest;
+export declare function createPageResult<TItem>(items: TItem[], input?: PageQueryInput): PageResult<TItem>;
+export declare function resolvePageCount(totalCount: number, pageSize: number): number;

package/dist/contracts/page.js

@@ -0,0 +1,44 @@
+const DEFAULT_PAGE = 1;
+const DEFAULT_PAGE_SIZE = 20;
+export function createPageQueryState(input = {}) {
+    const page = normalizePositiveInteger(input.page, DEFAULT_PAGE);
+    const pageSize = normalizePositiveInteger(input.pageSize, DEFAULT_PAGE_SIZE);
+    const keyword = input.keyword?.trim() || undefined;
+    const sorting = input.sorting?.trim() || undefined;
+    return {
+        page,
+        pageSize,
+        maxResultCount: pageSize,
+        skipCount: (page - 1) * pageSize,
+        ...(keyword === undefined ? {} : { keyword }),
+        ...(sorting === undefined ? {} : { sorting }),
+    };
+}
+export function createPagedRequest(input = {}) {
+    const query = createPageQueryState(input);
+    return {
+        skipCount: query.skipCount,
+        maxResultCount: query.maxResultCount,
+        ...(query.sorting === undefined ? {} : { sorting: query.sorting }),
+    };
+}
+export function createPageResult(items, input = {}) {
+    const query = createPageQueryState(input);
+    const totalCount = items.length;
+    const pagedItems = items.slice(query.skipCount, query.skipCount + query.pageSize);
+    return {
+        ...query,
+        items: pagedItems,
+        totalCount,
+        pageCount: resolvePageCount(totalCount, query.pageSize),
+    };
+}
+export function resolvePageCount(totalCount, pageSize) {
+    return Math.max(1, Math.ceil(Math.max(0, totalCount) / normalizePositiveInteger(pageSize, DEFAULT_PAGE_SIZE)));
+}
+function normalizePositiveInteger(value, fallback) {
+    if (!Number.isFinite(value) || !value || value < 1) {
+        return fallback;
+    }
+    return Math.floor(value);
+}

package/dist/contracts/runtime/datasource.d.ts

@@ -0,0 +1,109 @@
+import type { PageQueryState, PageResult } from '../page.js';
+import type { YoyoMutationContext, YoyoMutationInvalidationRequest } from './mutation.js';
+export interface YoyoEntityReference<TId = string> {
+    id: TId;
+}
+export interface YoyoQueryRequest<TFilter> {
+    state: PageQueryState;
+    filter: TFilter;
+    signal: AbortSignal;
+}
+export interface YoyoGetForEditRequest<TId = string> extends YoyoEntityReference<TId> {
+    signal: AbortSignal;
+}
+export interface YoyoGetForCreateRequest {
+    signal: AbortSignal;
+}
+export interface YoyoEntityMutationRequest<TId = string> extends YoyoEntityReference<TId> {
+    concurrencyToken?: string;
+    signal?: AbortSignal;
+    init?: RequestInit;
+}
+export interface YoyoWriteRequest<TValue> {
+    value: TValue;
+    signal?: AbortSignal;
+    init?: RequestInit;
+}
+export interface YoyoUpdateRequest<TValue> extends YoyoWriteRequest<TValue> {
+    concurrencyToken?: string;
+}
+export interface YoyoSetEnabledRequest<TId = string> extends YoyoEntityMutationRequest<TId> {
+    enabled: boolean;
+}
+export interface YoyoCrudDataSource<TFilter, TItem, TEdit, TSave, TId = string> {
+    readonly id: string;
+    query(request: YoyoQueryRequest<TFilter>): Promise<PageResult<TItem>>;
+    getForCreate?(request: YoyoGetForCreateRequest): Promise<TEdit>;
+    getForEdit(request: YoyoGetForEditRequest<TId>): Promise<TEdit>;
+    create?(request: YoyoWriteRequest<TSave>): Promise<TEdit | void>;
+    update?(request: YoyoUpdateRequest<TSave>): Promise<TEdit | void>;
+    remove?(request: YoyoEntityMutationRequest<TId>): Promise<void>;
+    setEnabled?(request: YoyoSetEnabledRequest<TId>): Promise<void>;
+    invalidate?(request: YoyoMutationInvalidationRequest<TId>): Promise<void> | void;
+}
+/**
+ * Provenance is attached at the feature-local adapter boundary so UI/runtime
+ * consumers cannot turn a mock into a production source by configuration.
+ */
+export type YoyoDatasourceBindingKind = 'fixture' | 'production';
+export type YoyoLinkingEnvironment = 'test' | 'demo' | 'development' | 'production';
+export interface YoyoDatasourceBinding<TDatasource extends {
+    readonly id: string;
+}> {
+    readonly kind: YoyoDatasourceBindingKind;
+    readonly datasource: TDatasource;
+}
+export interface YoyoDatasourceBindingLinkingInput<TDatasource extends {
+    readonly id: string;
+}> {
+    readonly environment: YoyoLinkingEnvironment;
+    readonly binding: YoyoDatasourceBinding<TDatasource>;
+}
+export interface YoyoDatasourceBindingDiagnostic {
+    readonly code: 'YDSB001';
+    readonly severity: 'blocking';
+    readonly message: string;
+    readonly guidance: string;
+}
+export declare class YoyoDatasourceBindingLinkingError extends Error {
+    readonly diagnostics: readonly YoyoDatasourceBindingDiagnostic[];
+    constructor(diagnostics: readonly YoyoDatasourceBindingDiagnostic[]);
+}
+/**
+ * The sole provenance gate for runtime datasource inputs. Fixture adapters use
+ * the same CRUD contract, but cannot cross the production linking boundary.
+ */
+export declare function linkYoyoDatasourceBinding<TDatasource extends {
+    readonly id: string;
+}>(input: YoyoDatasourceBindingLinkingInput<TDatasource>): YoyoDatasourceBinding<TDatasource>;
+export declare function defineYoyoCrudDataSource<TFilter, TItem, TEdit, TSave, TId = string>(datasource: YoyoCrudDataSource<TFilter, TItem, TEdit, TSave, TId>): YoyoCrudDataSource<TFilter, TItem, TEdit, TSave, TId>;
+export interface YoyoDatasourceRegistry<TDatasource extends {
+    readonly id: string;
+}> {
+    resolve(id: string): TDatasource;
+}
+export declare function createYoyoDatasourceRegistry<TDatasource extends {
+    readonly id: string;
+}>(datasources: readonly TDatasource[]): YoyoDatasourceRegistry<TDatasource>;
+export type YoyoCreateMutationCommand<TSave> = {
+    readonly operation: 'create';
+    readonly request: YoyoWriteRequest<TSave>;
+};
+export type YoyoUpdateMutationCommand<TSave> = {
+    readonly operation: 'update';
+    readonly request: YoyoUpdateRequest<TSave>;
+};
+export type YoyoEntityMutationCommand<TId> = {
+    readonly operation: 'remove';
+    readonly request: YoyoEntityMutationRequest<TId>;
+};
+export type YoyoSetEnabledMutationCommand<TId> = {
+    readonly operation: 'setEnabled';
+    readonly request: YoyoSetEnabledRequest<TId>;
+};
+/** Binds every mutation operation to its only valid payload shape. */
+export type YoyoCrudMutationCommand<TSave, TId> = YoyoCreateMutationCommand<TSave> | YoyoUpdateMutationCommand<TSave> | YoyoEntityMutationCommand<TId> | YoyoSetEnabledMutationCommand<TId>;
+/**
+ * 标准页面固定先等待后端 mutation 成功，再失效查询；失败时故意不触碰当前列表与编辑输入。
+ */
+export declare function executePessimisticMutation<TFilter, TItem, TEdit, TSave, TId>(datasource: YoyoCrudDataSource<TFilter, TItem, TEdit, TSave, TId>, command: YoyoCrudMutationCommand<TSave, TId>, context: YoyoMutationContext): Promise<void>;

package/dist/contracts/runtime/datasource.js

@@ -0,0 +1,89 @@
+export class YoyoDatasourceBindingLinkingError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        super(`Yoyo datasource binding linking failed: ${diagnostics.map((diagnostic) => diagnostic.code).join(', ')}`);
+        this.name = 'YoyoDatasourceBindingLinkingError';
+        this.diagnostics = diagnostics;
+    }
+}
+/**
+ * The sole provenance gate for runtime datasource inputs. Fixture adapters use
+ * the same CRUD contract, but cannot cross the production linking boundary.
+ */
+export function linkYoyoDatasourceBinding(input) {
+    if (input.environment === 'production' && input.binding.kind === 'fixture') {
+        throw new YoyoDatasourceBindingLinkingError([{
+                code: 'YDSB001',
+                severity: 'blocking',
+                message: `Fixture datasource '${input.binding.datasource.id}' cannot link in production.`,
+                guidance: 'Use a production feature-local datasource adapter before creating the runtime.',
+            }]);
+    }
+    return input.binding;
+}
+export function defineYoyoCrudDataSource(datasource) {
+    if (!datasource.id.trim()) {
+        throw new Error('Yoyo datasource id must not be empty.');
+    }
+    return datasource;
+}
+export function createYoyoDatasourceRegistry(datasources) {
+    const entries = new Map();
+    for (const datasource of datasources) {
+        if (!datasource.id.trim()) {
+            throw new Error('Datasource registry does not accept an empty id.');
+        }
+        if (entries.has(datasource.id)) {
+            throw new Error(`Datasource '${datasource.id}' is already registered.`);
+        }
+        entries.set(datasource.id, datasource);
+    }
+    return {
+        resolve(id) {
+            const datasource = entries.get(id);
+            if (!datasource) {
+                throw new Error(`Datasource '${id}' is not registered.`);
+            }
+            return datasource;
+        },
+    };
+}
+/**
+ * 标准页面固定先等待后端 mutation 成功，再失效查询；失败时故意不触碰当前列表与编辑输入。
+ */
+export async function executePessimisticMutation(datasource, command, context) {
+    switch (command.operation) {
+        case 'create':
+            if (!datasource.create) {
+                throw new Error(`Datasource '${datasource.id}' does not support create.`);
+            }
+            await datasource.create(command.request);
+            break;
+        case 'update':
+            if (!datasource.update) {
+                throw new Error(`Datasource '${datasource.id}' does not support update.`);
+            }
+            await datasource.update(command.request);
+            break;
+        case 'remove':
+            if (!datasource.remove) {
+                throw new Error(`Datasource '${datasource.id}' does not support remove.`);
+            }
+            await datasource.remove(command.request);
+            break;
+        case 'setEnabled':
+            if (!datasource.setEnabled) {
+                throw new Error(`Datasource '${datasource.id}' does not support setEnabled.`);
+            }
+            await datasource.setEnabled(command.request);
+            break;
+    }
+    await datasource.invalidate?.({
+        operation: command.operation === 'remove' ? 'softDelete' : command.operation,
+        ...(command.operation === 'remove' || command.operation === 'setEnabled'
+            ? { entityId: command.request.id }
+            : {}),
+        reason: 'success',
+        context,
+    });
+}

package/dist/contracts/runtime/error.d.ts

@@ -0,0 +1,23 @@
+export type YoyoDatasourceErrorKind = 'validation' | 'forbidden' | 'notFound' | 'conflict' | 'transient' | 'unknown';
+export interface YoyoDatasourceErrorInput {
+    status?: number;
+    message?: string;
+    validationErrors?: Record<string, readonly string[]>;
+}
+export interface YoyoDatasourceError {
+    kind: YoyoDatasourceErrorKind;
+    status: number;
+    message: string;
+    fieldErrors: Record<string, string[]>;
+}
+export interface YoyoDatasourceErrorHandling {
+    preserveInput: boolean;
+    showFieldErrors: boolean;
+    reload: boolean;
+    retry: boolean;
+}
+export interface YoyoDatasourceErrorPort<TTransportError = unknown> {
+    normalize(error: TTransportError): YoyoDatasourceError;
+}
+export declare function classifyYoyoDatasourceError(input: YoyoDatasourceErrorInput): YoyoDatasourceError;
+export declare function resolveYoyoDatasourceErrorHandling(kind: YoyoDatasourceErrorKind): YoyoDatasourceErrorHandling;

package/dist/contracts/runtime/error.js

@@ -0,0 +1,54 @@
+export function classifyYoyoDatasourceError(input) {
+    const fieldErrors = normalizeFieldErrors(input.validationErrors);
+    const status = Number.isInteger(input.status) ? input.status : 0;
+    return {
+        kind: classifyKind(status, fieldErrors),
+        status,
+        message: input.message?.trim() || '请求失败，请稍后重试。',
+        fieldErrors,
+    };
+}
+export function resolveYoyoDatasourceErrorHandling(kind) {
+    switch (kind) {
+        case 'validation':
+            return { preserveInput: true, showFieldErrors: true, reload: false, retry: false };
+        case 'forbidden':
+            return { preserveInput: false, showFieldErrors: false, reload: false, retry: false };
+        case 'notFound':
+        case 'conflict':
+            return { preserveInput: true, showFieldErrors: false, reload: true, retry: false };
+        case 'transient':
+            return { preserveInput: true, showFieldErrors: false, reload: false, retry: true };
+        case 'unknown':
+            return { preserveInput: true, showFieldErrors: false, reload: false, retry: false };
+    }
+}
+function classifyKind(status, fieldErrors) {
+    if (status === 422 || (status === 400 && Object.keys(fieldErrors).length > 0))
+        return 'validation';
+    if (status === 401 || status === 403)
+        return 'forbidden';
+    if (status === 404)
+        return 'notFound';
+    if (status === 409)
+        return 'conflict';
+    if (isRetryableStatus(status))
+        return 'transient';
+    return 'unknown';
+}
+/**
+ * 只有真正代表「服务暂时不可用、稍后可能恢复」的状态才归入 transient。
+ * 刻意排除 500：ABP 的用户友好异常默认返回 500，业务规则失败（例如「角色已绑定用户，无法删除」）
+ * 落在这一档；若把它当作 transient，界面会引导用户「稍后重试」，而重试永远不会成功。
+ * 因此 500 归入 unknown —— 保留输入、不自动重新加载、不提示重试。
+ */
+function isRetryableStatus(status) {
+    return status === 408 || status === 429 || status === 502 || status === 503 || status === 504;
+}
+function normalizeFieldErrors(errors) {
+    if (!errors)
+        return {};
+    return Object.fromEntries(Object.entries(errors)
+        .map(([field, messages]) => [field, messages.filter((message) => message.trim().length > 0)])
+        .filter(([, messages]) => messages.length > 0));
+}

package/dist/contracts/runtime/mutation.d.ts

@@ -0,0 +1,49 @@
+import type { YoyoDatasourceErrorKind } from './error.js';
+export type YoyoMutationOperation = 'create' | 'update' | 'setEnabled' | 'softDelete';
+/**
+ * Host-independent identity for one page mutation. scopeKey is deliberately
+ * opaque: the feature adapter owns how Host/Tenant or another boundary is
+ * represented, while the runtime only carries it through.
+ */
+export interface YoyoMutationContext {
+    readonly pageKey: string;
+    readonly actionKey: string;
+    readonly scopeKey: string;
+}
+export type YoyoMutationInvalidationReason = 'success' | 'failure';
+export interface YoyoMutationInvalidationRequest<TId = string> {
+    readonly operation: YoyoMutationOperation;
+    readonly entityId?: TId;
+    readonly reason: YoyoMutationInvalidationReason;
+    readonly context: YoyoMutationContext;
+}
+export declare function createYoyoMutationContext(input: YoyoMutationContext): YoyoMutationContext;
+export interface YoyoMutationConfirmRequest<TId = string> {
+    operation: YoyoMutationOperation;
+    entityId?: TId;
+    context: YoyoMutationContext;
+}
+export interface YoyoMutationConfirmPort<TId = string> {
+    confirm(request: YoyoMutationConfirmRequest<TId>): Promise<boolean>;
+}
+export type YoyoMutationFeedbackEvent<TId = string> = {
+    operation: YoyoMutationOperation;
+    entityId?: TId;
+    outcome: 'success';
+    context: YoyoMutationContext;
+} | {
+    operation: YoyoMutationOperation;
+    entityId?: TId;
+    outcome: 'failure';
+    errorKind: YoyoDatasourceErrorKind;
+    /**
+     * Backend-owned friendly message for this failure. The runtime carries the
+     * normalized backend message verbatim; presentation decides how to show it
+     * (toast/warning/form) but must not replace it with a fixed string.
+     */
+    message: string;
+    context: YoyoMutationContext;
+};
+export interface YoyoMutationFeedbackPort<TId = string> {
+    publish(event: YoyoMutationFeedbackEvent<TId>): Promise<void> | void;
+}

package/dist/contracts/runtime/mutation.js

@@ -0,0 +1,12 @@
+export function createYoyoMutationContext(input) {
+    for (const [key, value] of Object.entries(input)) {
+        if (typeof value !== 'string' || value.trim().length === 0) {
+            throw new Error(`Yoyo mutation context '${key}' must be a non-empty string.`);
+        }
+    }
+    return Object.freeze({
+        pageKey: input.pageKey,
+        actionKey: input.actionKey,
+        scopeKey: input.scopeKey,
+    });
+}

package/dist/contracts/runtime/policy.d.ts

@@ -0,0 +1,16 @@
+import type { YoyoAdminFeatureKey, YoyoAdminPermissionKey } from '../generated/capability/index.js';
+export interface YoyoCapabilityPolicy {
+    permissions?: readonly YoyoAdminPermissionKey[];
+    features?: readonly YoyoAdminFeatureKey[];
+}
+export interface YoyoCapabilityRuntime {
+    grantedPermissions: ReadonlySet<YoyoAdminPermissionKey>;
+    enabledFeatures: ReadonlySet<YoyoAdminFeatureKey>;
+}
+export interface YoyoCapabilityPolicyResult {
+    allowed: boolean;
+    missingPermissions: YoyoAdminPermissionKey[];
+    missingFeatures: YoyoAdminFeatureKey[];
+}
+/** 前端只解释当前 runtime grant；后端仍是最终授权裁决者。 */
+export declare function evaluateYoyoCapabilityPolicy(policy: YoyoCapabilityPolicy, runtime: YoyoCapabilityRuntime): YoyoCapabilityPolicyResult;

package/dist/contracts/runtime/policy.js

@@ -0,0 +1,10 @@
+/** 前端只解释当前 runtime grant；后端仍是最终授权裁决者。 */
+export function evaluateYoyoCapabilityPolicy(policy, runtime) {
+    const missingPermissions = (policy.permissions ?? []).filter((permission) => !runtime.grantedPermissions.has(permission));
+    const missingFeatures = (policy.features ?? []).filter((feature) => !runtime.enabledFeatures.has(feature));
+    return {
+        allowed: missingPermissions.length === 0 && missingFeatures.length === 0,
+        missingPermissions,
+        missingFeatures,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './contracts/index.js';
+export * from './auth/index.js';
+export * from './abp/index.js';
+export * from './temporal/index.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './contracts/index.js';
+export * from './auth/index.js';
+export * from './abp/index.js';
+export * from './temporal/index.js';

package/dist/temporal/index.d.ts

@@ -0,0 +1,21 @@
+import type { YoyoTemporalContext } from '../contracts/index.js';
+export declare const YOYO_WALL_CLOCK_FORMAT = "YYYY-MM-DD HH:mm:ss";
+export declare const YOYO_DATE_ONLY_FORMAT = "YYYY-MM-DD";
+export declare const YOYO_TIME_ONLY_FORMAT = "HH:mm:ss";
+export type YoyoTemporalErrorCode = 'invalid-instant' | 'invalid-wall-clock' | 'nonexistent-wall-clock' | 'invalid-date-only' | 'invalid-time-only';
+export declare class YoyoTemporalConversionError extends Error {
+    readonly code: YoyoTemporalErrorCode;
+    readonly value: string;
+    constructor(code: YoyoTemporalErrorCode, value: string, message: string);
+}
+export interface YoyoTemporalRuntime {
+    readonly context: YoyoTemporalContext;
+    instantToWallClock(instant: string, format?: string): string;
+    wallClockToInstant(wallClock: string, format?: string): string;
+    formatInstant(instant: string, format?: string): string;
+    dateOnly(value: string): string;
+    timeOnly(value: string): string;
+    expiryDateToInstant(dateOnly: string): string;
+    instantToExpiryDate(instant: string): string;
+}
+export declare function createYoyoTemporalRuntime(context: YoyoTemporalContext): YoyoTemporalRuntime;

package/dist/temporal/index.js

@@ -0,0 +1,78 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import timezone from 'dayjs/plugin/timezone.js';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(customParseFormat);
+export const YOYO_WALL_CLOCK_FORMAT = 'YYYY-MM-DD HH:mm:ss';
+export const YOYO_DATE_ONLY_FORMAT = 'YYYY-MM-DD';
+export const YOYO_TIME_ONLY_FORMAT = 'HH:mm:ss';
+export class YoyoTemporalConversionError extends Error {
+    code;
+    value;
+    constructor(code, value, message) {
+        super(message);
+        this.name = 'YoyoTemporalConversionError';
+        this.code = code;
+        this.value = value;
+    }
+}
+export function createYoyoTemporalRuntime(context) {
+    const frozenContext = Object.freeze({ ...context });
+    assertTimeZone(frozenContext.timeZoneIana);
+    return Object.freeze({
+        context: frozenContext,
+        instantToWallClock(instant, format = YOYO_WALL_CLOCK_FORMAT) {
+            const parsed = dayjs.utc(instant);
+            if (!parsed.isValid()) {
+                throw new YoyoTemporalConversionError('invalid-instant', instant, '时间不是有效的 UTC instant。');
+            }
+            return parsed.tz(frozenContext.timeZoneIana).format(format);
+        },
+        wallClockToInstant(wallClock, format = YOYO_WALL_CLOCK_FORMAT) {
+            const strictInput = dayjs(wallClock, format, true);
+            if (!strictInput.isValid() || strictInput.format(format) !== wallClock) {
+                throw new YoyoTemporalConversionError('invalid-wall-clock', wallClock, '时间格式无效。');
+            }
+            const parsed = dayjs.tz(wallClock, format, frozenContext.timeZoneIana);
+            if (parsed.format(format) !== wallClock) {
+                throw new YoyoTemporalConversionError('nonexistent-wall-clock', wallClock, '该本地时间因夏令时切换而不存在。');
+            }
+            return parsed.utc().toISOString();
+        },
+        formatInstant(instant, format = YOYO_WALL_CLOCK_FORMAT) {
+            return this.instantToWallClock(instant, format);
+        },
+        dateOnly(value) {
+            return validatePlainValue(value, YOYO_DATE_ONLY_FORMAT, 'invalid-date-only', '日期格式无效。');
+        },
+        timeOnly(value) {
+            return validatePlainValue(value, YOYO_TIME_ONLY_FORMAT, 'invalid-time-only', '时间格式无效。');
+        },
+        expiryDateToInstant(dateOnly) {
+            const date = validatePlainValue(dateOnly, YOYO_DATE_ONLY_FORMAT, 'invalid-date-only', '日期格式无效。');
+            const nextDate = dayjs(date, YOYO_DATE_ONLY_FORMAT, true).add(1, 'day').format(YOYO_DATE_ONLY_FORMAT);
+            return this.wallClockToInstant(`${nextDate} 00:00:00`);
+        },
+        instantToExpiryDate(instant) {
+            const boundaryDate = this.instantToWallClock(instant, YOYO_DATE_ONLY_FORMAT);
+            return dayjs(boundaryDate, YOYO_DATE_ONLY_FORMAT, true).subtract(1, 'day').format(YOYO_DATE_ONLY_FORMAT);
+        },
+    });
+}
+function validatePlainValue(value, format, code, message) {
+    const parsed = dayjs(value, format, true);
+    if (!parsed.isValid() || parsed.format(format) !== value) {
+        throw new YoyoTemporalConversionError(code, value, message);
+    }
+    return value;
+}
+function assertTimeZone(timeZoneIana) {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: timeZoneIana }).format(0);
+    }
+    catch {
+        throw new YoyoTemporalConversionError('invalid-wall-clock', timeZoneIana, '业务时区不是有效的 IANA timezone。');
+    }
+}