@oomol-lab/open-flow 0.1.0-beta.72 → 0.1.0-beta.74

package/src/json-schema-subset/expression/result.ts

@@ -0,0 +1,88 @@
+import type { DeepReadonly } from '../utils.ts'
+
+import { deepFreeze } from '../utils.ts'
+
+export type ExpressionResult = number
+
+export const ExpressionSingleResult = Object.freeze({
+  Equals: 0,
+  Containing: 1,
+  ContainedBy: 2,
+  Rejection: 3,
+  Intersection: 4,
+})
+
+export type ExpressionSingleResult = (typeof ExpressionSingleResult)[keyof typeof ExpressionSingleResult]
+
+export const ExpressionEquals = toExpression(ExpressionSingleResult.Equals)
+export const ExpressionContaining = toExpression(ExpressionSingleResult.Containing)
+export const ExpressionContainedBy = toExpression(ExpressionSingleResult.ContainedBy)
+export const ExpressionRejection = toExpression(ExpressionSingleResult.Rejection)
+export const ExpressionIntersection = toExpression(ExpressionSingleResult.Intersection)
+
+export const ExpressionMaskList: DeepReadonly<[ExpressionSingleResult, ExpressionResult][]> = deepFreeze([
+  [ExpressionSingleResult.Equals, ExpressionEquals],
+  [ExpressionSingleResult.Containing, ExpressionContaining],
+  [ExpressionSingleResult.ContainedBy, ExpressionContainedBy],
+  [ExpressionSingleResult.Rejection, ExpressionRejection],
+  [ExpressionSingleResult.Intersection, ExpressionIntersection],
+])
+
+export const ExpressionNone = 0
+export const ExpressionAny = ((): ExpressionResult => {
+  let expression = ExpressionNone
+  for (const [_, mask] of ExpressionMaskList) {
+    expression |= mask
+  }
+  return expression
+})()
+
+export function toString(expression: ExpressionResult): string {
+  const strList: string[] = [
+    hasEquals(expression) ? 'E' : '_',
+    hasContaining(expression) ? 'C' : '_',
+    hasContainedBy(expression) ? 'B' : '_',
+    hasRejection(expression) ? 'R' : '_',
+    hasIntersection(expression) ? 'I' : '_',
+  ]
+  return strList.join('')
+}
+
+export function hasEquals(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionEquals)
+}
+
+export function hasContaining(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionContaining)
+}
+
+export function hasContainedBy(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionContainedBy)
+}
+
+export function hasRejection(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionRejection)
+}
+
+export function hasIntersection(expression: ExpressionResult): boolean {
+  return !!(expression & ExpressionIntersection)
+}
+
+export function toExpression(expression: ExpressionSingleResult): ExpressionResult {
+  return 1 << expression
+}
+
+export function toSingleExpression(expression: ExpressionResult): ExpressionSingleResult | -1 {
+  let result: ExpressionSingleResult | -1 = -1
+  for (const [singleResult, mask] of ExpressionMaskList) {
+    if (mask & expression) {
+      if (result !== -1) {
+        // A second single result means that the expression is not singular.
+        result = -1
+        break
+      }
+      result = singleResult
+    }
+  }
+  return result
+}

package/src/json-schema-subset/expression/types.ts

@@ -0,0 +1,36 @@
+import type { ExpressionResult } from './result.ts'
+
+export type ExpressionDescription<E> =
+  | {
+      readonly kind: typeof ExpressionKind.Leaf
+    }
+  | {
+      readonly kind: typeof ExpressionKind.Not
+      readonly expression: E
+    }
+  | {
+      readonly kind: typeof ExpressionKind.AllOf | typeof ExpressionKind.AnyOf | typeof ExpressionKind.OneOf
+      readonly expressions: Iterable<E>
+    }
+
+export const ExpressionKind = Object.freeze({
+  Leaf: 0,
+  Not: 1,
+  AllOf: 2,
+  AnyOf: 3,
+  OneOf: 4,
+})
+
+export type ExpressionKind = (typeof ExpressionKind)[keyof typeof ExpressionKind]
+
+export type Calculator<E> = (e1: E, e2: E) => ExpressionResult
+export type Equaler<E> = (e1: E, e2: E) => boolean
+export type Describer<E> = (e: E) => ExpressionDescription<E>
+export type CalculationObserver<E> = (e1: E, e2: E, result: ExpressionResult, swapped: boolean) => void
+
+export type ExpressionDelegate<E> = {
+  readonly describe: Describer<E>
+  readonly equals: Equaler<E>
+  readonly calculate: Calculator<E>
+  readonly observeCalculation?: CalculationObserver<E> | undefined
+}

package/src/json-schema-subset/extends/extendsContext.ts

@@ -0,0 +1,89 @@
+import type { ExpressionResult } from '../expression/index.ts'
+import type { Schema } from '../types.ts'
+import type { ExtendsSchema, ExtendsSchemaClass } from './types.ts'
+
+import { toExpression, ExpressionNone, ExpressionSingleResult } from '../expression/index.ts'
+import { createId } from '../utils.ts'
+
+export class ExtendsContext {
+  private readonly extendsSchemaClasses: readonly ExtendsSchemaClass[]
+
+  public constructor(extendsSchemaClasses: readonly ExtendsSchemaClass[] = []) {
+    this.extendsSchemaClasses = Object.freeze([...extendsSchemaClasses])
+  }
+
+  public tryCompiledExtendsSchema(target: object, payload?: unknown): ExtendsSchema | null {
+    for (const extendsSchemaClass of this.extendsSchemaClasses) {
+      if (extendsSchemaClass.isMatch(target)) {
+        return new extendsSchemaClass(createId(), target, payload)
+      }
+    }
+    return null
+  }
+
+  public isExtendsSchema(target: object): target is ExtendsSchema {
+    for (const extendsSchemaClass of this.extendsSchemaClasses) {
+      if (target instanceof extendsSchemaClass) {
+        return true
+      }
+    }
+    return false
+  }
+
+  public calculate(schema1: Schema<unknown>, schema2: Schema<unknown>): ExpressionResult {
+    const schemaClass = this.findMatchedClass(schema1, schema2)
+    const shouldSwap = !(schema1 instanceof schemaClass)
+
+    let expressionResult: ExpressionResult = ExpressionNone
+    let result: readonly ExpressionSingleResult[]
+
+    if (shouldSwap) {
+      result = (schema2 as ExtendsSchema).compare(schema1)
+    } else {
+      result = schema1.compare(schema2)
+    }
+    for (let expression of result) {
+      if (shouldSwap) {
+        expression = ExtendsContext.swap(expression)
+      }
+      expressionResult |= toExpression(expression)
+    }
+    return expressionResult
+  }
+
+  public equals(schema1: Schema<unknown>, schema2: Schema<unknown>): boolean {
+    const schemaClass = this.findMatchedClass(schema1, schema2)
+    const shouldSwap = !(schema1 instanceof schemaClass)
+    if (shouldSwap) {
+      return (schema2 as ExtendsSchema).equals(schema1)
+    } else {
+      return schema1.equals(schema2)
+    }
+  }
+
+  private findMatchedClass(schema1: Schema<unknown>, schema2: Schema<unknown>): ExtendsSchemaClass {
+    for (const schemaClass of this.extendsSchemaClasses) {
+      if (schema1 instanceof schemaClass) {
+        return schemaClass
+      }
+      if (schema2 instanceof schemaClass) {
+        return schemaClass
+      }
+    }
+    throw new Error('Invalid schema')
+  }
+
+  private static swap(expression: ExpressionSingleResult): ExpressionSingleResult {
+    switch (expression) {
+      case ExpressionSingleResult.Containing: {
+        return ExpressionSingleResult.ContainedBy
+      }
+      case ExpressionSingleResult.ContainedBy: {
+        return ExpressionSingleResult.Containing
+      }
+      default: {
+        return expression
+      }
+    }
+  }
+}

package/src/json-schema-subset/extends/index.ts

@@ -0,0 +1,2 @@
+export type { ExtendsSchemaClass, ExtendsSchema } from './types.ts'
+export { ExtendsContext } from './extendsContext.ts'

package/src/json-schema-subset/extends/types.ts

@@ -0,0 +1,12 @@
+import type { ExpressionSingleResult } from '../expression/index.ts'
+
+export interface ExtendsSchemaClass {
+  new (id: number, value: unknown, payload?: unknown): ExtendsSchema
+  isMatch(value: unknown): boolean
+}
+
+export interface ExtendsSchema {
+  readonly id: number
+  compare(other: unknown): readonly ExpressionSingleResult[]
+  equals(other: unknown): boolean
+}

package/src/json-schema-subset/global.ts

@@ -0,0 +1,60 @@
+import type { CompilableSchema, InputSchema } from './compiler/index.ts'
+import type { ExtendsSchemaClass } from './extends/index.ts'
+import type { Compiler } from './preprocessing.ts'
+import type { Schema } from './types.ts'
+import type { JSONDelegate } from './types.ts'
+
+import { checkWithResult } from './checker/checker.ts'
+import { compile } from './compiler/index.ts'
+import { hasContainedBy, hasContaining, hasEquals, hasIntersection, hasRejection } from './expression/index.ts'
+import { ExtendsContext } from './extends/index.ts'
+import { preprocessSchema, preprocessSchemasPair } from './preprocessing.ts'
+
+export type MakingParams<E> = {
+  readonly extendsSchemaClasses?: readonly ExtendsSchemaClass[]
+  readonly delegate?: JSONDelegate<E>
+}
+
+export interface SubsetCompare<E> {
+  compile(schema: InputSchema, payload?: unknown, printWarnLog?: boolean): Schema<E>
+  isSubset(superSchema: CompilableSchema<E>, subSchema: CompilableSchema<E>, printWarnLog?: boolean): SubsetComparison
+}
+
+export interface SubsetComparison {
+  readonly errorPath?: readonly (string | number)[] | undefined
+  readonly result: SubsetCompareResult
+}
+
+export const SubsetCompareResult = Object.freeze({
+  True: 0,
+  False: 1,
+  Unknown: 2,
+})
+
+export type SubsetCompareResult = (typeof SubsetCompareResult)[keyof typeof SubsetCompareResult]
+
+export function makeSubsetCompare<E = unknown>({ extendsSchemaClasses, delegate }: MakingParams<E> = {}): SubsetCompare<E> {
+  const extendsContext = new ExtendsContext(extendsSchemaClasses)
+  const comparer: SubsetCompare<E> = Object.freeze({
+    compile: (schema: InputSchema, payload?: unknown, printWarnLog?: boolean): Schema<E> => {
+      const compiler: Compiler<E> = (candidate) => compile(candidate, extendsContext, payload, delegate)
+      return preprocessSchema(schema, compiler, printWarnLog)
+    },
+    isSubset: (superSchema: CompilableSchema<E>, subSchema: CompilableSchema<E>, printWarnLog = false): SubsetComparison => {
+      const compiler: Compiler<E> = (candidate) => compile(candidate, extendsContext, undefined, delegate)
+      const [schema1, schema2] = preprocessSchemasPair(superSchema, subSchema, compiler, printWarnLog)
+      const { errorPath, expression } = checkWithResult(extendsContext, schema1, schema2)
+      const foundTrueExpression = hasEquals(expression) || hasContainedBy(expression)
+      const foundFalseExpression = hasContaining(expression) || hasIntersection(expression) || hasRejection(expression)
+
+      if (foundTrueExpression && !foundFalseExpression) {
+        return { result: SubsetCompareResult.True }
+      }
+      if (!foundTrueExpression && foundFalseExpression) {
+        return { errorPath, result: SubsetCompareResult.False }
+      }
+      return { result: SubsetCompareResult.Unknown }
+    },
+  })
+  return comparer
+}

package/src/json-schema-subset/index.ts

@@ -0,0 +1,8 @@
+export type { SubsetCompare, SubsetComparison } from './global.ts'
+export type { Schema, JSONDelegate } from './types.ts'
+export type { ExtendsSchema, ExtendsSchemaClass } from './extends/index.ts'
+export type { InputSchema, CompiledSchema } from './compiler/index.ts'
+export type { SchemaError } from './error.ts'
+
+export { ExpressionSingleResult } from './expression/index.ts'
+export { makeSubsetCompare, SubsetCompareResult } from './global.ts'

package/src/json-schema-subset/preprocessing.ts

@@ -0,0 +1,74 @@
+import type { CompilableSchema, CompileResult } from './compiler/index.ts'
+import type { CompiledSchemaErrorItem, SchemaErrorItem } from './error.ts'
+import type { Schema } from './types.ts'
+
+import { SchemaError, stringifySchemaError } from './error.ts'
+
+export type Compiler<E> = (schema: CompilableSchema<E>) => CompileResult<E> | readonly SchemaErrorItem<E>[]
+
+export function preprocessSchema<E>(schema: CompilableSchema<E>, compile: Compiler<E>, printWarnLog = false): Schema<E> {
+  const schemaResult = compile(schema)
+  if (Array.isArray(schemaResult)) {
+    const errorItems: SchemaErrorItem[] = []
+    collectWithPathPrefix(errorItems, schemaResult, '$')
+    throw new SchemaError(errorItems)
+  }
+  const { schema: compiledSchema, warns } = schemaResult as CompileResult<E>
+  if (printWarnLog && warns.length > 0) {
+    console.warn(`found ${warns.length} warns after compile schema`)
+    for (const warn of warns) {
+      console.warn(stringifySchemaError(warn))
+    }
+  }
+  return compiledSchema
+}
+
+export function preprocessSchemasPair<E>(
+  schema1: CompilableSchema<E>,
+  schema2: CompilableSchema<E>,
+  compile: Compiler<E>,
+  printWarnLog = false,
+): [Schema<E>, Schema<E>] {
+  const schemaResult1 = compile(schema1)
+  const schemaResult2 = compile(schema2)
+
+  if (Array.isArray(schemaResult1) || Array.isArray(schemaResult2)) {
+    const errorItems: SchemaErrorItem[] = []
+
+    if (Array.isArray(schemaResult1)) {
+      collectWithPathPrefix(errorItems, schemaResult1, '$1')
+    }
+    if (Array.isArray(schemaResult2)) {
+      collectWithPathPrefix(errorItems, schemaResult2, '$2')
+    }
+    throw new SchemaError(errorItems)
+  }
+  const { schema: compiledSchema1, warns: superWarns } = schemaResult1 as CompileResult<E>
+  const { schema: compiledSchema2, warns: subWarns } = schemaResult2 as CompileResult<E>
+
+  if (printWarnLog) {
+    if (superWarns.length > 0) {
+      console.warn(`found ${superWarns.length} warns after compile superSchema`)
+    }
+    for (const warn of superWarns) {
+      console.warn(stringifySchemaError(warn))
+    }
+    if (subWarns.length > 0) {
+      console.warn(`found ${subWarns.length} warns after compile subSchema`)
+    }
+    for (const warn of subWarns) {
+      console.warn(stringifySchemaError(warn))
+    }
+  }
+  return [compiledSchema1, compiledSchema2]
+}
+
+function collectWithPathPrefix(errorItems: SchemaErrorItem[], compiledItems: readonly CompiledSchemaErrorItem[], prefix: number | string): void {
+  for (const compiledItem of compiledItems) {
+    const replacedItem: SchemaErrorItem = {
+      ...compiledItem,
+      path: [prefix, ...compiledItem.path],
+    }
+    errorItems.push(replacedItem)
+  }
+}

package/src/json-schema-subset/types.ts

@@ -0,0 +1,8 @@
+import type { CompiledSchema } from './compiler/index.ts'
+import type { ExtendsSchema } from './extends/index.ts'
+
+export type Schema<E> = ExtendsSchema | CompiledSchema<E>
+export interface JSONDelegate<E = unknown> {
+  isSchema(schema: object): boolean | readonly E[]
+  compile(schema: object): (value: unknown) => boolean | readonly E[]
+}

package/src/json-schema-subset/utils.ts

@@ -0,0 +1,95 @@
+export type DeepReadonly<T> = T extends (...args: never[]) => unknown ? T : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T
+
+let nextId = 0
+
+export function createId(): number {
+  const id = nextId
+  nextId += 1
+  return id
+}
+
+export function deepFreeze<T>(target: T): DeepReadonly<T> {
+  if (typeof target === 'object' && target !== null && !Object.isFrozen(target)) {
+    for (const key of Object.getOwnPropertyNames(target)) {
+      const value: unknown = Reflect.get(target, key)
+      deepFreeze(value)
+    }
+    Object.freeze(target)
+  }
+  return target as DeepReadonly<T>
+}
+
+export function pick<T extends object, K extends keyof T>(target: T, keys: Iterable<K>): { -readonly [P in K]: T[P] } {
+  const newTarget: Record<string | number | symbol, unknown> = {}
+  for (const key of keys) {
+    if (key in target) {
+      newTarget[key] = target[key]
+    }
+  }
+  return newTarget as Pick<T, K>
+}
+
+export function deepCopy<T>(value: T): T {
+  if (typeof value !== 'object' || value === null) {
+    return value
+  } else if (Array.isArray(value)) {
+    const array: unknown[] = []
+    for (const [i, element] of value.entries()) {
+      array[i] = deepCopy(element)
+    }
+    return array as T
+  } else {
+    const newObject: { [key: string]: unknown } = {}
+    for (const key in value) {
+      newObject[key] = deepCopy(value[key])
+    }
+    return newObject as T
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+export function isDeepEquals(value1: any, value2: any): boolean {
+  if (value1 === value2) {
+    return true
+  }
+  if (value1 === null) {
+    return false
+  }
+  if (typeof value1 !== 'object') {
+    return false
+  }
+  if (typeof value1 !== typeof value2) {
+    return false
+  }
+  if (Array.isArray(value1)) {
+    if (!Array.isArray(value2)) {
+      return false
+    }
+    if (value1.length !== value2.length) {
+      return false
+    }
+    for (const [i, value1Element] of value1.entries()) {
+      if (!isDeepEquals(value1Element, value2[i])) {
+        return false
+      }
+    }
+  } else {
+    if (Array.isArray(value2)) {
+      return false
+    }
+    for (const key in value1) {
+      if (!(key in value2)) {
+        return false
+      }
+      if (!isDeepEquals(value1[key], value2[key])) {
+        return false
+      }
+    }
+    for (const key in value2) {
+      if (!(key in value1)) {
+        return false
+      }
+    }
+  }
+  return true
+}

package/src/localization/common/languages.ts

@@ -0,0 +1,118 @@
+export const uiLanguages = ['en', 'zh-CN', 'zh-TW', 'ja', 'ko', 'ru', 'fr'] as const
+
+export type UiLanguage = (typeof uiLanguages)[number]
+
+export const defaultUiLanguage: UiLanguage = 'en'
+
+/** Endonyms, shown in language pickers regardless of the current UI language. */
+export const uiLanguageNames: Readonly<Record<UiLanguage, string>> = {
+  'en': 'English',
+  'zh-CN': '简体中文',
+  'zh-TW': '繁體中文',
+  'ja': '日本語',
+  'ko': '한국어',
+  'ru': 'Русский',
+  'fr': 'Français',
+}
+
+const uiLanguageTags: ReadonlyMap<string, UiLanguage> = new Map(uiLanguages.map((language) => [language.toLowerCase(), language]))
+const traditionalChineseRegions: ReadonlySet<string> = new Set(['hk', 'mo', 'tw'])
+const cjkLanguages: ReadonlySet<UiLanguage> = new Set<UiLanguage>(['zh-CN', 'zh-TW', 'ja', 'ko'])
+
+export function isUiLanguage(value: unknown): value is UiLanguage {
+  return typeof value == 'string' && uiLanguageTags.get(value.toLowerCase()) == value
+}
+
+/**
+ * BCP 47 aware resolution over candidates such as `navigator.languages`: an exact tag match
+ * (case-insensitive) wins; for zh an explicit script subtag beats the region (zh-Hant-* to zh-TW,
+ * zh-Hans-* to zh-CN), then zh-TW, zh-HK and zh-MO map to zh-TW and any other zh* to zh-CN; en, ja,
+ * ko, ru and fr also match on their primary subtag (fr-CA to fr, ja-JP to ja).
+ */
+export function resolveUiLanguage(candidates: Iterable<string | null | undefined>, fallback: UiLanguage = defaultUiLanguage): UiLanguage {
+  for (const candidate of candidates) {
+    const language = candidate == null ? undefined : matchUiLanguage(candidate)
+    if (language != null) return language
+  }
+  return fallback
+}
+
+/** Languages written with CJK scripts: zh-CN, zh-TW, ja and ko. */
+export function isCjkLanguage(language: string): boolean {
+  const matched = matchUiLanguage(language)
+  return matched != null && cjkLanguages.has(matched)
+}
+
+/**
+ * Lookup order for package-author locale files (`oo-locales/<lang>.json`), which only exist for en
+ * and zh-CN today. Traditional Chinese readers prefer Simplified Chinese over English; every other
+ * language falls back to English first. The chain never repeats a locale.
+ */
+export function userLocaleFallbackChain(language: string): readonly string[] {
+  if (language == 'zh-TW') return ['zh-TW', 'zh-CN', 'en']
+  if (language == 'zh-CN') return ['zh-CN', 'en']
+  if (language == 'en') return ['en', 'zh-CN']
+  return [language, 'en', 'zh-CN']
+}
+
+function matchUiLanguage(candidate: string): UiLanguage | undefined {
+  const tag = candidate.trim().toLowerCase()
+  if (tag.length == 0) return undefined
+  const exact = uiLanguageTags.get(tag)
+  if (exact != null) return exact
+  const subtags = tag.split('-')
+  if (subtags[0] == 'zh') {
+    if (subtags.includes('hant')) return 'zh-TW'
+    if (subtags.includes('hans')) return 'zh-CN'
+    return subtags.some((subtag) => traditionalChineseRegions.has(subtag)) ? 'zh-TW' : 'zh-CN'
+  }
+  return uiLanguageTags.get(subtags[0]!)
+}
+
+/** Resolve metadata query/header preferences using the same language mapping as the UI. */
+export function resolveMetadataLanguage(query: string | undefined, acceptLanguage?: string): UiLanguage {
+  if (query != null) {
+    const canonical = Intl.getCanonicalLocales(query.trim())[0]
+    if (canonical == null) throw new RangeError('locale must be a valid BCP 47 language tag')
+    return resolveUiLanguage([canonical])
+  }
+  const candidates = (acceptLanguage ?? '').split(',').flatMap<{ tag: string; q: number; order: number; language: UiLanguage | undefined }>((part, order) => {
+    const [tag, ...parameters] = part.trim().split(';')
+    const quality = parameters
+      .find((parameter) => parameter.trim().startsWith('q='))
+      ?.trim()
+      .slice(2)
+    const q = quality == null ? 1 : Number(quality)
+    if (!tag || !Number.isFinite(q) || q < 0 || q > 1) return []
+    if (tag == '*') return [{ tag, q, order, language: undefined }]
+    try {
+      const canonical = Intl.getCanonicalLocales(tag)[0]
+      const language = canonical == null ? undefined : matchUiLanguage(canonical)
+      return language == null ? [] : [{ tag, q, order, language }]
+    } catch {
+      return []
+    }
+  })
+  const preferences = uiLanguages
+    .flatMap((language) => {
+      const matches = candidates
+        .filter((candidate) => candidate.tag == '*' || candidate.language == language)
+        .toSorted((a, b) => (b.tag == '*' ? 0 : b.tag.split('-').length) - (a.tag == '*' ? 0 : a.tag.split('-').length) || a.order - b.order)
+      const candidate = matches[0]
+      return candidate == null || candidate.q == 0 ? [] : [{ language, q: candidate.q, order: candidate.order }]
+    })
+    .toSorted((a, b) => b.q - a.q || a.order - b.order)
+  return preferences[0]?.language ?? defaultUiLanguage
+}
+
+export function importedWorkflowName(language: UiLanguage): string {
+  return {
+    'en': 'Imported workflow',
+    'zh-CN': '导入的工作流',
+    'zh-TW': '匯入的工作流',
+    'ja': 'インポートしたワークフロー',
+    'ko': '가져온 워크플로',
+    'fr': 'Workflow importé',
+    'ru': 'Импортированный процесс',
+  }[language]
+}

package/src/localization/common/timeZone.ts

@@ -0,0 +1,25 @@
+/** Validate a named timezone using the same runtime data used for date conversion. */
+export function isTimeZone(value: string): boolean {
+  try {
+    Intl.DateTimeFormat('en', { timeZone: value })
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function timeZoneOffsetMinutes(timezone: string, at: Date = new Date()): number | undefined {
+  try {
+    const offset = new Intl.DateTimeFormat('en-US', { timeZone: timezone, timeZoneName: 'longOffset' })
+      .formatToParts(at)
+      .find((part) => part.type === 'timeZoneName')?.value
+    if (offset == null) return
+    if (offset === 'GMT') return 0
+    const match = /^GMT([+-])(\d{2}):(\d{2})$/.exec(offset)
+    if (match == null) return
+    const minutes = Number(match[2]) * 60 + Number(match[3])
+    return match[1] === '-' ? -minutes : minutes
+  } catch {
+    return
+  }
+}

package/src/openapi/common/authBindings.ts

@@ -0,0 +1,12 @@
+import type { FlowDocument } from '../../flow/common/change.ts'
+
+/** Never allow credentials to enter a Revision as literal node inputs. */
+export function assertOpenApiAuthBindings(document: FlowDocument): void {
+  for (const node of Object.values(document.graph.nodes)) {
+    if (node.kind != 'task' || !('executor' in node.task) || node.task.executor.kind != 'openapi') continue
+    for (const [handle, mapping] of Object.entries(node.inputs)) {
+      if (handle.startsWith('auth.') && mapping.kind == 'value')
+        throw new TypeError('OpenAPI authentication accepts deployment variables and upstream outputs only.')
+    }
+  }
+}