@rex0220/ksql-flownet 1.0.0

package/dist/dag/topological-sort.js

@@ -0,0 +1,32 @@
+export function stableTopologicalSort(nodes) {
+    const indexById = new Map(nodes.map((node, index) => [node.id, index]));
+    const indegree = new Map(nodes.map((node) => [node.id, node.depends_on.length]));
+    const dependents = new Map(nodes.map((node) => [node.id, []]));
+    for (const node of nodes) {
+        for (const dependency of node.depends_on) {
+            dependents.get(dependency)?.push(node.id);
+        }
+    }
+    const ready = nodes
+        .filter((node) => indegree.get(node.id) === 0)
+        .map((node) => node.id);
+    const order = [];
+    while (ready.length > 0) {
+        ready.sort((left, right) => (indexById.get(left) ?? 0) - (indexById.get(right) ?? 0));
+        const current = ready.shift();
+        if (current === undefined)
+            break;
+        order.push(current);
+        for (const dependent of dependents.get(current) ?? []) {
+            const remaining = (indegree.get(dependent) ?? 0) - 1;
+            indegree.set(dependent, remaining);
+            if (remaining === 0)
+                ready.push(dependent);
+        }
+    }
+    const cyclicNodeIds = nodes
+        .filter((node) => (indegree.get(node.id) ?? 0) > 0)
+        .map((node) => node.id);
+    return { order, cyclicNodeIds };
+}
+//# sourceMappingURL=topological-sort.js.map

package/dist/domain/business-key.d.ts

@@ -0,0 +1,15 @@
+import { type BusinessKeyPolicy, type ScheduledPeriodPolicy, type ValidationError } from "./network-definition.js";
+export interface BusinessKeyInput {
+    readonly networkId: string;
+    readonly policy: BusinessKeyPolicy;
+    readonly scheduledFor?: string;
+    readonly businessKey?: string;
+}
+export interface BusinessKeyResult {
+    readonly businessKey?: string;
+    readonly errors: readonly ValidationError[];
+}
+export declare function normalizeScheduledFor(value: string): string | undefined;
+export declare function validateScheduledPeriodPolicy(policy: ScheduledPeriodPolicy): ValidationError[];
+export declare function resolveBusinessKey(input: BusinessKeyInput): BusinessKeyResult;
+//# sourceMappingURL=business-key.d.ts.map

package/dist/domain/business-key.js

@@ -0,0 +1,249 @@
+import { MAX_BUSINESS_KEY_LENGTH, } from "./network-definition.js";
+const ISO_TIMESTAMP_WITH_OFFSET = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?(Z|([+-])(\d{2}):(\d{2}))$/;
+const ALLOWED_PLACEHOLDERS = new Set([
+    "{network_id}",
+    "{yyyy}",
+    "{MM}",
+    "{dd}",
+]);
+function hasControlCharacter(value) {
+    return [...value].some((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+    });
+}
+function isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function daysInMonth(year, month) {
+    const days = [
+        31,
+        isLeapYear(year) ? 29 : 28,
+        31,
+        30,
+        31,
+        30,
+        31,
+        31,
+        30,
+        31,
+        30,
+        31,
+    ];
+    return days[month - 1] ?? 0;
+}
+function parseScheduledFor(value) {
+    const match = ISO_TIMESTAMP_WITH_OFFSET.exec(value);
+    if (match === null)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = Number(match[4]);
+    const minute = Number(match[5]);
+    const second = match[6] === undefined ? 0 : Number(match[6]);
+    const offsetHour = match[10] === undefined ? 0 : Number(match[10]);
+    const offsetMinute = match[11] === undefined ? 0 : Number(match[11]);
+    // Intl/Date cannot faithfully represent arbitrary precision or extended
+    // years. Reject those forms instead of silently normalizing them.
+    if (year === 0 ||
+        month < 1 ||
+        month > 12 ||
+        day < 1 ||
+        day > daysInMonth(year, month) ||
+        hour > 23 ||
+        minute > 59 ||
+        second > 59 ||
+        offsetHour > 14 ||
+        offsetMinute > 59 ||
+        (offsetHour === 14 && offsetMinute !== 0)) {
+        return undefined;
+    }
+    const epochMilliseconds = Date.parse(value);
+    return Number.isFinite(epochMilliseconds)
+        ? new Date(epochMilliseconds)
+        : undefined;
+}
+export function normalizeScheduledFor(value) {
+    return parseScheduledFor(value)?.toISOString();
+}
+function calendarDateAt(date, timeZone) {
+    const formatter = new Intl.DateTimeFormat("en-CA-u-ca-gregory-nu-latn", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    });
+    const parts = new Map(formatter
+        .formatToParts(date)
+        .filter((part) => part.type !== "literal")
+        .map((part) => [part.type, part.value]));
+    const yyyy = parts.get("year");
+    const MM = parts.get("month");
+    const dd = parts.get("day");
+    if (yyyy === undefined || MM === undefined || dd === undefined) {
+        throw new Error("Intl did not return the requested calendar date parts");
+    }
+    return { yyyy, MM, dd };
+}
+export function validateScheduledPeriodPolicy(policy) {
+    const errors = [];
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: policy.timezone }).format();
+    }
+    catch {
+        errors.push({
+            code: "TIMEZONE_INVALID",
+            path: "$.business_key_policy.timezone",
+            message: `unknown IANA timezone '${policy.timezone}'`,
+        });
+    }
+    const placeholders = policy.format.match(/\{[^{}]*\}/g) ?? [];
+    for (const placeholder of placeholders) {
+        if (!ALLOWED_PLACEHOLDERS.has(placeholder)) {
+            errors.push({
+                code: "FORMAT_PLACEHOLDER_UNSUPPORTED",
+                path: "$.business_key_policy.format",
+                message: `unsupported placeholder '${placeholder}'`,
+            });
+        }
+    }
+    const remainder = placeholders.reduce((value, placeholder) => value.replace(placeholder, ""), policy.format);
+    if (remainder.includes("{") || remainder.includes("}")) {
+        errors.push({
+            code: "FORMAT_PLACEHOLDER_INVALID",
+            path: "$.business_key_policy.format",
+            message: "contains an invalid placeholder expression",
+        });
+    }
+    // A period label must retain every coarser calendar component; otherwise
+    // different days, months, or years could collapse to the same key.
+    const required = policy.period === "day" ? ["{yyyy}", "{MM}", "{dd}"] : ["{yyyy}", "{MM}"];
+    for (const placeholder of required) {
+        if (!placeholders.includes(placeholder)) {
+            errors.push({
+                code: "FORMAT_PERIOD_MISMATCH",
+                path: "$.business_key_policy.format",
+                message: `period '${policy.period}' requires placeholder '${placeholder}'`,
+            });
+        }
+    }
+    // Phase 1 month keys represent a normalized month boundary. Including a day
+    // would make the same month depend on the scheduled day, so fail closed.
+    if (policy.period === "month" && placeholders.includes("{dd}")) {
+        errors.push({
+            code: "FORMAT_PERIOD_MISMATCH",
+            path: "$.business_key_policy.format",
+            message: "period 'month' must not use placeholder '{dd}'",
+        });
+    }
+    return errors;
+}
+function validateBusinessKey(value, path) {
+    const errors = [];
+    if (value.length === 0) {
+        errors.push({
+            code: "BUSINESS_KEY_EMPTY",
+            path,
+            message: "must not be empty",
+        });
+    }
+    if (value.length > MAX_BUSINESS_KEY_LENGTH) {
+        errors.push({
+            code: "BUSINESS_KEY_TOO_LONG",
+            path,
+            message: `must be at most ${MAX_BUSINESS_KEY_LENGTH} characters`,
+        });
+    }
+    if (hasControlCharacter(value)) {
+        errors.push({
+            code: "BUSINESS_KEY_CONTROL_CHARACTER",
+            path,
+            message: "must not contain NUL, newline, or other control characters",
+        });
+    }
+    return errors;
+}
+export function resolveBusinessKey(input) {
+    const errors = [];
+    if (input.policy.type === "explicit") {
+        if (input.scheduledFor !== undefined) {
+            errors.push({
+                code: "SCHEDULED_FOR_NOT_ALLOWED",
+                path: "--scheduled-for",
+                message: "is not allowed when business_key_policy.type is 'explicit'",
+            });
+        }
+        if (input.businessKey === undefined) {
+            errors.push({
+                code: "BUSINESS_KEY_REQUIRED",
+                path: "--business-key",
+                message: "is required when business_key_policy.type is 'explicit'",
+            });
+            return { errors };
+        }
+        errors.push(...validateBusinessKey(input.businessKey, "--business-key"));
+        return errors.length === 0
+            ? { businessKey: input.businessKey, errors }
+            : { errors };
+    }
+    const policyErrors = validateScheduledPeriodPolicy(input.policy);
+    errors.push(...policyErrors);
+    const { businessKey: providedBusinessKey, scheduledFor: scheduledForInput } = input;
+    if (scheduledForInput === undefined) {
+        if (providedBusinessKey === undefined) {
+            errors.push({
+                code: "SCHEDULED_FOR_REQUIRED",
+                path: "--scheduled-for/--business-key",
+                message: "either --scheduled-for or --business-key is required when business_key_policy.type is 'scheduled_period'",
+            });
+            return { errors };
+        }
+        errors.push(...validateBusinessKey(providedBusinessKey, "--business-key"));
+        return errors.length === 0
+            ? { businessKey: providedBusinessKey, errors }
+            : { errors };
+    }
+    const scheduledFor = parseScheduledFor(scheduledForInput);
+    if (scheduledFor === undefined) {
+        errors.push({
+            code: "SCHEDULED_FOR_INVALID",
+            path: "--scheduled-for",
+            message: "must be a valid ISO 8601 timestamp with an explicit offset",
+        });
+        return { errors };
+    }
+    if (policyErrors.length > 0)
+        return { errors };
+    if (providedBusinessKey !== undefined) {
+        errors.push(...validateBusinessKey(providedBusinessKey, "--business-key"));
+        return errors.length === 0
+            ? { businessKey: providedBusinessKey, errors }
+            : { errors };
+    }
+    let calendarDate;
+    try {
+        calendarDate = calendarDateAt(scheduledFor, input.policy.timezone);
+    }
+    catch {
+        errors.push({
+            code: "TIMEZONE_INVALID",
+            path: "$.business_key_policy.timezone",
+            message: `unknown IANA timezone '${input.policy.timezone}'`,
+        });
+        return { errors };
+    }
+    const replacements = {
+        "{network_id}": input.networkId,
+        "{yyyy}": calendarDate.yyyy,
+        "{MM}": calendarDate.MM,
+        // A month policy is normalized to its month boundary. Validation forbids
+        // {dd} for month, while using "01" here keeps this function total if an
+        // already-validated policy is accidentally bypassed.
+        "{dd}": input.policy.period === "month" ? "01" : calendarDate.dd,
+    };
+    const businessKey = input.policy.format.replace(/\{[^{}]*\}/g, (placeholder) => replacements[placeholder] ?? placeholder);
+    errors.push(...validateBusinessKey(businessKey, "$.business_key_policy.format"));
+    return errors.length === 0 ? { businessKey, errors } : { errors };
+}
+//# sourceMappingURL=business-key.js.map

package/dist/domain/canonical-lock-key.d.ts

@@ -0,0 +1,17 @@
+export declare const MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH = 128;
+export declare const CANONICAL_LOCK_KEY_LENGTH = 46;
+export declare const MAX_KINTONE_UNIQUE_KEY_LENGTH = 64;
+declare const canonicalLockKeyBrand: unique symbol;
+export type CanonicalLockKey<Prefix extends "N1" | "J1"> = `${Prefix}:${string}` & {
+    readonly [canonicalLockKeyBrand]: Prefix;
+};
+export type CanonicalLockKeyErrorCode = "LOCK_KEY_IDENTIFIER_NOT_STRING" | "LOCK_KEY_IDENTIFIER_EMPTY" | "LOCK_KEY_IDENTIFIER_NUL" | "LOCK_KEY_IDENTIFIER_SEPARATOR" | "LOCK_KEY_IDENTIFIER_RESERVED" | "LOCK_KEY_IDENTIFIER_TOO_LONG" | "LOCK_KEY_LENGTH_INVARIANT";
+export declare class CanonicalLockKeyError extends Error {
+    readonly code: CanonicalLockKeyErrorCode;
+    readonly component: "profile" | "networkId" | "jobId" | "generatedKey";
+    constructor(code: CanonicalLockKeyErrorCode, component: "profile" | "networkId" | "jobId" | "generatedKey", message: string);
+}
+export declare function networkLockKey(profile: string, networkId: string): CanonicalLockKey<"N1">;
+export declare function jobLockKey(profile: string, jobId: string): CanonicalLockKey<"J1">;
+export {};
+//# sourceMappingURL=canonical-lock-key.d.ts.map

package/dist/domain/canonical-lock-key.js

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto";
+// Keep these rules aligned with the identifier constraints enforced by
+// schemas/network-definition.schema.json and validate-network.ts.
+export const MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH = 128;
+export const CANONICAL_LOCK_KEY_LENGTH = 46;
+export const MAX_KINTONE_UNIQUE_KEY_LENGTH = 64;
+export class CanonicalLockKeyError extends Error {
+    code;
+    component;
+    constructor(code, component, message) {
+        super(message);
+        this.name = "CanonicalLockKeyError";
+        this.code = code;
+        this.component = component;
+    }
+}
+function canonicalIdentifier(value, component) {
+    if (typeof value !== "string") {
+        throw new CanonicalLockKeyError("LOCK_KEY_IDENTIFIER_NOT_STRING", component, `${component} must be a string`);
+    }
+    if (value.length === 0) {
+        throw new CanonicalLockKeyError("LOCK_KEY_IDENTIFIER_EMPTY", component, `${component} must not be empty`);
+    }
+    if (value.includes("\0")) {
+        throw new CanonicalLockKeyError("LOCK_KEY_IDENTIFIER_NUL", component, `${component} must not contain NUL`);
+    }
+    if (value.includes(":")) {
+        throw new CanonicalLockKeyError("LOCK_KEY_IDENTIFIER_SEPARATOR", component, `${component} must not contain ':'`);
+    }
+    if (value === "__net__") {
+        throw new CanonicalLockKeyError("LOCK_KEY_IDENTIFIER_RESERVED", component, `${component} must not use reserved identifier '__net__'`);
+    }
+    const normalized = value.normalize("NFC");
+    const length = Array.from(normalized).length;
+    if (length > MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH) {
+        throw new CanonicalLockKeyError("LOCK_KEY_IDENTIFIER_TOO_LONG", component, `${component} must be at most ${MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH} Unicode characters after NFC normalization`);
+    }
+    return normalized;
+}
+function lockKey(prefix, profile, identifier, component) {
+    const canonicalProfile = canonicalIdentifier(profile, "profile");
+    const canonicalTarget = canonicalIdentifier(identifier, component);
+    const canonicalInput = `${prefix}\0${canonicalProfile}\0${canonicalTarget}`;
+    const digest = createHash("sha256")
+        .update(canonicalInput, "utf8")
+        .digest("base64url");
+    const key = `${prefix}:${digest}`;
+    if (key.length !== CANONICAL_LOCK_KEY_LENGTH ||
+        key.length > MAX_KINTONE_UNIQUE_KEY_LENGTH) {
+        throw new CanonicalLockKeyError("LOCK_KEY_LENGTH_INVARIANT", "generatedKey", "generated canonical lock key violates its length contract");
+    }
+    return key;
+}
+export function networkLockKey(profile, networkId) {
+    return lockKey("N1", profile, networkId, "networkId");
+}
+export function jobLockKey(profile, jobId) {
+    return lockKey("J1", profile, jobId, "jobId");
+}
+//# sourceMappingURL=canonical-lock-key.js.map

package/dist/domain/canonical-record-key.d.ts

@@ -0,0 +1,18 @@
+export declare const CANONICAL_RECORD_KEY_LENGTH = 46;
+declare const canonicalRecordKeyBrand: unique symbol;
+export type CanonicalRecordKey<Prefix extends "R1" | "S1" | "A1"> = `${Prefix}:${string}` & {
+    readonly [canonicalRecordKeyBrand]: Prefix;
+};
+export type CanonicalRecordKeyErrorCode = "RECORD_KEY_IDENTIFIER_NOT_STRING" | "RECORD_KEY_IDENTIFIER_EMPTY" | "RECORD_KEY_IDENTIFIER_NUL" | "RECORD_KEY_IDENTIFIER_SEPARATOR" | "RECORD_KEY_IDENTIFIER_RESERVED" | "RECORD_KEY_IDENTIFIER_TOO_LONG" | "RECORD_KEY_ATTEMPT_NO_INVALID" | "RECORD_KEY_LENGTH_INVARIANT";
+type RecordKeyIdentifierComponent = "profile" | "networkId" | "businessKey" | "runId" | "nodeId";
+type RecordKeyComponent = RecordKeyIdentifierComponent | "attemptNo" | "generatedKey";
+export declare class CanonicalRecordKeyError extends Error {
+    readonly code: CanonicalRecordKeyErrorCode;
+    readonly component: RecordKeyComponent;
+    constructor(code: CanonicalRecordKeyErrorCode, component: RecordKeyComponent, message: string);
+}
+export declare function runKey(profile: string, networkId: string, businessKey: string): CanonicalRecordKey<"R1">;
+export declare function nodeStateKey(runId: string, nodeId: string): CanonicalRecordKey<"S1">;
+export declare function attemptKey(runId: string, nodeId: string, attemptNo: number): CanonicalRecordKey<"A1">;
+export {};
+//# sourceMappingURL=canonical-record-key.d.ts.map

package/dist/domain/canonical-record-key.js

@@ -0,0 +1,70 @@
+import { createHash } from "node:crypto";
+import { MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH, MAX_KINTONE_UNIQUE_KEY_LENGTH, } from "./canonical-lock-key.js";
+export const CANONICAL_RECORD_KEY_LENGTH = 46;
+export class CanonicalRecordKeyError extends Error {
+    code;
+    component;
+    constructor(code, component, message) {
+        super(message);
+        this.name = "CanonicalRecordKeyError";
+        this.code = code;
+        this.component = component;
+    }
+}
+function canonicalIdentifier(value, component) {
+    if (typeof value !== "string") {
+        throw new CanonicalRecordKeyError("RECORD_KEY_IDENTIFIER_NOT_STRING", component, `${component} must be a string`);
+    }
+    if (value.length === 0) {
+        throw new CanonicalRecordKeyError("RECORD_KEY_IDENTIFIER_EMPTY", component, `${component} must not be empty`);
+    }
+    if (value.includes("\0")) {
+        throw new CanonicalRecordKeyError("RECORD_KEY_IDENTIFIER_NUL", component, `${component} must not contain NUL`);
+    }
+    if (value.includes(":")) {
+        throw new CanonicalRecordKeyError("RECORD_KEY_IDENTIFIER_SEPARATOR", component, `${component} must not contain ':'`);
+    }
+    if (value === "__net__") {
+        throw new CanonicalRecordKeyError("RECORD_KEY_IDENTIFIER_RESERVED", component, `${component} must not use reserved identifier '__net__'`);
+    }
+    const normalized = value.normalize("NFC");
+    if (Array.from(normalized).length > MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH) {
+        throw new CanonicalRecordKeyError("RECORD_KEY_IDENTIFIER_TOO_LONG", component, `${component} must be at most ${MAX_CANONICAL_LOCK_IDENTIFIER_LENGTH} Unicode characters after NFC normalization`);
+    }
+    return normalized;
+}
+function canonicalKey(prefix, components) {
+    const digest = createHash("sha256")
+        .update([prefix, ...components].join("\0"), "utf8")
+        .digest("base64url");
+    const key = `${prefix}:${digest}`;
+    if (key.length !== CANONICAL_RECORD_KEY_LENGTH ||
+        key.length > MAX_KINTONE_UNIQUE_KEY_LENGTH) {
+        throw new CanonicalRecordKeyError("RECORD_KEY_LENGTH_INVARIANT", "generatedKey", "generated canonical record key violates its length contract");
+    }
+    return key;
+}
+export function runKey(profile, networkId, businessKey) {
+    return canonicalKey("R1", [
+        canonicalIdentifier(profile, "profile"),
+        canonicalIdentifier(networkId, "networkId"),
+        canonicalIdentifier(businessKey, "businessKey"),
+    ]);
+}
+export function nodeStateKey(runId, nodeId) {
+    return canonicalKey("S1", [
+        canonicalIdentifier(runId, "runId"),
+        canonicalIdentifier(nodeId, "nodeId"),
+    ]);
+}
+export function attemptKey(runId, nodeId, attemptNo) {
+    if (!Number.isSafeInteger(attemptNo) || attemptNo < 1) {
+        throw new CanonicalRecordKeyError("RECORD_KEY_ATTEMPT_NO_INVALID", "attemptNo", "attemptNo must be a positive safe integer");
+    }
+    return canonicalKey("A1", [
+        canonicalIdentifier(runId, "runId"),
+        canonicalIdentifier(nodeId, "nodeId"),
+        String(attemptNo),
+    ]);
+}
+//# sourceMappingURL=canonical-record-key.js.map

package/dist/domain/load-network.d.ts

@@ -0,0 +1,4 @@
+import type { ValidationResult } from "./network-definition.js";
+export declare function loadNetworkDefinition(path: string): ValidationResult;
+export declare function loadNetworkDefinitionSource(source: string): ValidationResult;
+//# sourceMappingURL=load-network.d.ts.map

package/dist/domain/load-network.js

@@ -0,0 +1,47 @@
+import { readFileSync } from "node:fs";
+import { parseDocument } from "yaml";
+import { validateNetworkDefinition } from "./validate-network.js";
+export function loadNetworkDefinition(path) {
+    let source;
+    try {
+        source = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        return {
+            errors: [
+                {
+                    code: "NETWORK_FILE_UNREADABLE",
+                    path: "$",
+                    message: `cannot read network file: ${String(error)}`,
+                },
+            ],
+        };
+    }
+    return loadNetworkDefinitionSource(source);
+}
+export function loadNetworkDefinitionSource(source) {
+    const document = parseDocument(source, { uniqueKeys: true });
+    if (document.errors.length > 0) {
+        const errors = document.errors.map((error) => ({
+            code: "YAML_PARSE_ERROR",
+            path: "$",
+            message: `invalid YAML: ${error.message}`,
+        }));
+        return { errors };
+    }
+    try {
+        return validateNetworkDefinition(document.toJS());
+    }
+    catch (error) {
+        return {
+            errors: [
+                {
+                    code: "YAML_VALUE_INVALID",
+                    path: "$",
+                    message: `invalid YAML value: ${String(error)}`,
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=load-network.js.map

package/dist/domain/network-definition.d.ts

@@ -0,0 +1,47 @@
+export declare const MAX_IDENTIFIER_LENGTH = 128;
+export declare const MAX_BUSINESS_KEY_LENGTH = 128;
+export type TriggerRule = "all_success" | "none_failed" | "all_done";
+export interface ScheduledPeriodPolicy {
+    readonly type: "scheduled_period";
+    readonly period: "day" | "month";
+    readonly timezone: string;
+    readonly format: string;
+}
+export interface ExplicitPolicy {
+    readonly type: "explicit";
+}
+export type BusinessKeyPolicy = ScheduledPeriodPolicy | ExplicitPolicy;
+export interface NetworkLockDefinition {
+    readonly lease_duration_sec: number;
+    readonly heartbeat_interval_sec: number;
+}
+export interface NetworkNodeDefinition {
+    readonly id: string;
+    readonly job_id: string;
+    readonly sql: string;
+    readonly depends_on: readonly string[];
+    readonly trigger_rule: TriggerRule;
+    readonly idempotent: boolean;
+    readonly inputs?: Readonly<Record<string, string>>;
+    readonly outputs?: Readonly<Record<string, string>>;
+}
+export interface NetworkDefinition {
+    readonly schema_version: 1;
+    readonly network_id: string;
+    readonly description?: string;
+    readonly business_key_policy: BusinessKeyPolicy;
+    readonly max_active_runs: number;
+    readonly network_lock: NetworkLockDefinition;
+    readonly nodes: readonly NetworkNodeDefinition[];
+}
+export interface ValidationError {
+    readonly code: ValidationErrorCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type ValidationErrorCode = "NETWORK_FILE_UNREADABLE" | "YAML_PARSE_ERROR" | "YAML_VALUE_INVALID" | "SCHEMA_INVALID" | "UNKNOWN_PROPERTY" | "TIMEZONE_INVALID" | "FORMAT_PLACEHOLDER_UNSUPPORTED" | "FORMAT_PLACEHOLDER_INVALID" | "FORMAT_PERIOD_MISMATCH" | "NETWORK_LOCK_HEARTBEAT_NOT_LESS_THAN_LEASE" | "NETWORK_LOCK_HEARTBEAT_EXCEEDS_ONE_THIRD" | "DUPLICATE_NODE_ID" | "INPUT_PATTERN_INVALID" | "OUTPUT_PATTERN_INVALID" | "TRIGGER_RULE_UNSUPPORTED" | "SELF_DEPENDENCY" | "DUPLICATE_DEPENDENCY" | "UNKNOWN_DEPENDENCY" | "CYCLE_DETECTED" | "SQL_FILE_UNREADABLE" | "SCHEDULED_FOR_REQUIRED" | "SCHEDULED_FOR_NOT_ALLOWED" | "SCHEDULED_FOR_INVALID" | "BUSINESS_KEY_INPUT_CONFLICT" | "BUSINESS_KEY_REQUIRED" | "BUSINESS_KEY_NOT_ALLOWED" | "BUSINESS_KEY_EMPTY" | "BUSINESS_KEY_TOO_LONG" | "BUSINESS_KEY_CONTROL_CHARACTER";
+export interface ValidationResult {
+    readonly definition?: NetworkDefinition;
+    readonly errors: readonly ValidationError[];
+}
+//# sourceMappingURL=network-definition.d.ts.map

package/dist/domain/network-definition.js

@@ -0,0 +1,7 @@
+// TODO(D-10): replace this conservative limit when the canonical key and
+// backing-field limits are frozen.
+export const MAX_IDENTIFIER_LENGTH = 128;
+// TODO(D-10): replace this conservative limit when the backing business-key
+// field and canonical lock-key limits are frozen.
+export const MAX_BUSINESS_KEY_LENGTH = 128;
+//# sourceMappingURL=network-definition.js.map