@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/automations/occurrence-preparation.js

@@ -0,0 +1,257 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { selectAutomationInputBatch } from "./input-batch-selection.js";
+import { createAutomationSnapshotStaging } from "./snapshot-staging.js";
+import { baselineFileRecord, cachedContentVersion, commitInputObservation, eligibleFileRecord, findSourceVersion, hasSourceBaseline, isReusableSourceInput, MAX_INPUT_SNAPSHOT_BYTES, recordsForSource, sourceBaselineMarker, } from "./input-ledger.js";
+import { captureSourceFile, discoverSourceFiles, } from "./source-discovery.js";
+function sourceFailure(error) {
+    if (error instanceof Error && error.message === "automation_source_changed")
+        return "automation_source_changed";
+    if (error instanceof Error && error.message === "automation_source_capacity_exceeded")
+        return "automation_source_capacity_exceeded";
+    return "automation_source_unavailable";
+}
+function failedForJob(job, error, terminalAt) {
+    return {
+        kind: "failed",
+        error,
+        commit: (state, runId) => {
+            state.executions.push({
+                id: runId,
+                automationId: job.target.automationId,
+                definitionRevision: job.target.definitionRevision,
+                revision: 1,
+                inputIds: [],
+                nodes: [],
+                reportRef: `derived:${runId}`,
+                terminalAt,
+            });
+        },
+    };
+}
+function sourceFree(job) {
+    return {
+        kind: "ready",
+        inputIds: [],
+        commit: (state, runId) => {
+            state.executions.push({
+                id: runId,
+                automationId: job.target.automationId,
+                definitionRevision: job.target.definitionRevision,
+                revision: 1,
+                inputIds: [],
+                nodes: [],
+            });
+        },
+    };
+}
+async function planSource(input) {
+    const discovered = await discoverSourceFiles({
+        source: input.source,
+        paths: input.config.paths,
+        now: input.now,
+    });
+    const records = recordsForSource(input.state, input.definition.automationId, input.source.sourceId);
+    const firstScan = !hasSourceBaseline(records, discovered.root);
+    if (firstScan && !input.source.includeExisting && discovered.unstableCount > 0)
+        return "unstable_baseline";
+    const establishExcludingBaseline = firstScan && !input.source.includeExisting;
+    const excludedInputIds = [];
+    const baselineFiles = [];
+    const candidates = [];
+    const refresh = [];
+    for (const file of discovered.files) {
+        const cached = cachedContentVersion(file, records);
+        const captured = cached ? undefined : await captureSourceFile(file);
+        const version = cached ?? captured.contentVersion;
+        const existing = findSourceVersion(records, file.canonicalPath, version);
+        const existingVersionNeedsBaseline = existing && establishExcludingBaseline;
+        if (existingVersionNeedsBaseline) {
+            excludedInputIds.push(existing.id);
+            continue;
+        }
+        if (existing) {
+            if (!cached)
+                refresh.push({
+                    recordId: existing.id, file, observedAt: input.observedAt,
+                });
+            if (isReusableSourceInput(existing, records, discovered.root))
+                candidates.push({ file, existing });
+            continue;
+        }
+        if (establishExcludingBaseline) {
+            baselineFiles.push(baselineFileRecord({
+                automationId: input.definition.automationId,
+                sourceId: input.source.sourceId,
+                file: captured,
+                observedAt: input.observedAt,
+            }));
+            continue;
+        }
+        candidates.push({ file, contentVersion: version });
+    }
+    const marker = firstScan ? sourceBaselineMarker({
+        automationId: input.definition.automationId,
+        sourceId: input.source.sourceId,
+        root: discovered.root,
+        observedAt: input.observedAt,
+        excludedInputIds,
+    }) : undefined;
+    return { marker, baselineFiles, candidates, refresh };
+}
+function selectedCandidates(definition, source, candidates) {
+    const threshold = definition.trigger.kind === "folder"
+        ? definition.trigger.minimumEligibleFiles : 1;
+    const maxFiles = source.mode === "per_file" ? 1 : source.maxBatchFiles;
+    return selectAutomationInputBatch(candidates, threshold, maxFiles);
+}
+function verifyPlanFits(state, plan, newFiles, existingIds, runId) {
+    const preview = structuredClone(state);
+    commitInputObservation({
+        state: preview,
+        marker: plan.marker,
+        baselineFiles: plan.baselineFiles,
+        newFiles,
+        selectedExistingIds: existingIds,
+        refresh: plan.refresh,
+        runId,
+    });
+}
+export function createAutomationOccurrencePreparer(options) {
+    const snapshots = options.snapshots ?? createAutomationSnapshotStaging({
+        runtimeDir: options.config.paths.runtimeDir, persistence: options.persistence,
+        attachments: options.attachments,
+    });
+    return async (job, candidateRunId) => {
+        const now = options.now?.() ?? Date.now();
+        const observedAt = new Date(now).toISOString();
+        const state = await options.persistence.read();
+        const definition = state.definitions.find((item) => item.automationId === job.target.automationId &&
+            item.revision === job.target.definitionRevision)?.definition;
+        if (!definition)
+            return failedForJob(job, "automation_definition_not_found", observedAt);
+        if (!definition.source) {
+            return definition.trigger.kind === "folder"
+                ? failedForJob(job, "automation_source_unavailable", observedAt)
+                : sourceFree(job);
+        }
+        let plan;
+        try {
+            await snapshots.reconcile();
+            plan = await planSource({
+                definition,
+                source: definition.source,
+                state,
+                config: options.config,
+                observedAt,
+                now,
+            });
+        }
+        catch (error) {
+            const code = sourceFailure(error);
+            return code === "automation_source_changed"
+                ? { kind: "no_input" }
+                : failedForJob(job, code, observedAt);
+        }
+        if (plan === "unstable_baseline")
+            return { kind: "no_input" };
+        let selected;
+        try {
+            selected = selectedCandidates(definition, definition.source, plan.candidates);
+        }
+        catch (error) {
+            return failedForJob(job, sourceFailure(error), observedAt);
+        }
+        if (selected.length === 0) {
+            try {
+                verifyPlanFits(state, plan, [], []);
+            }
+            catch (error) {
+                return failedForJob(job, sourceFailure(error), observedAt);
+            }
+            return {
+                kind: "no_input",
+                commit: plan.marker || plan.baselineFiles.length || plan.refresh.length
+                    ? (current) => commitInputObservation({
+                        state: current,
+                        marker: plan.marker,
+                        baselineFiles: plan.baselineFiles,
+                        refresh: plan.refresh,
+                    })
+                    : undefined,
+            };
+        }
+        const retainedBytes = state.inputs.reduce((bytes, record) => bytes + (record.snapshot?.sizeBytes ?? 0), 0);
+        const newBytes = selected.reduce((bytes, candidate) => bytes + (candidate.existing ? 0 : candidate.file.sizeBytes), 0);
+        if (retainedBytes + newBytes > MAX_INPUT_SNAPSHOT_BYTES)
+            return failedForJob(job, "automation_source_capacity_exceeded", observedAt);
+        const newFiles = [];
+        const existingIds = [];
+        try {
+            const needsNewSnapshots = selected.some((candidate) => !candidate.existing);
+            if (needsNewSnapshots)
+                await snapshots.begin(candidateRunId);
+            for (const candidate of selected) {
+                if (candidate.existing) {
+                    existingIds.push(candidate.existing.id);
+                    continue;
+                }
+                const captured = await captureSourceFile(candidate.file);
+                if (captured.contentVersion !== candidate.contentVersion)
+                    throw new Error("automation_source_changed");
+                const id = randomUUID();
+                const attachment = await options.attachments.saveAttachment({
+                    sessionId: candidateRunId,
+                    requestId: id,
+                    kind: captured.kind,
+                    mimeType: captured.mimeType,
+                    bytes: captured.bytes,
+                    name: basename(captured.canonicalPath),
+                });
+                newFiles.push(eligibleFileRecord({
+                    id,
+                    automationId: definition.automationId,
+                    sourceId: definition.source.sourceId,
+                    file: captured,
+                    observedAt,
+                    attachment,
+                }));
+            }
+            verifyPlanFits(state, plan, newFiles, existingIds, candidateRunId);
+        }
+        catch (error) {
+            await snapshots.discard(candidateRunId);
+            const code = sourceFailure(error);
+            return code === "automation_source_changed"
+                ? { kind: "no_input" }
+                : failedForJob(job, code, observedAt);
+        }
+        const inputIds = [...existingIds, ...newFiles.map((record) => record.id)];
+        return {
+            kind: "ready",
+            inputIds,
+            commit: (current, runId) => {
+                commitInputObservation({
+                    state: current,
+                    marker: plan.marker,
+                    baselineFiles: plan.baselineFiles,
+                    newFiles,
+                    selectedExistingIds: existingIds,
+                    refresh: plan.refresh,
+                    runId,
+                });
+                current.executions.push({
+                    id: runId,
+                    automationId: job.target.automationId,
+                    definitionRevision: job.target.definitionRevision,
+                    revision: 1,
+                    inputIds,
+                    nodes: [],
+                });
+            },
+            discard: newFiles.length > 0
+                ? () => snapshots.discard(candidateRunId)
+                : undefined,
+        };
+    };
+}

package/dist/src/runtime/automations/permission-grants.d.ts

@@ -0,0 +1,27 @@
+import type { SchedulerToolPermissionMode } from "../scheduler/tool-permission-mode.js";
+import type { OperationRef } from "./definition-contracts.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationGrantRecord } from "./storage-records.js";
+export declare function sameOperation(left: OperationRef, right: OperationRef): boolean;
+export type GrantableAutomationOperation = Readonly<{
+    operation: OperationRef;
+    requiredMode: SchedulerToolPermissionMode;
+}>;
+export declare function currentAutomationGrant(records: readonly AutomationGrantRecord[], environmentId: string, automationId: string): AutomationGrantRecord | null;
+export declare function permitsAutomationOperation(grant: AutomationGrantRecord | null, environmentId: string, automationId: string, selected: OperationRef, requiredMode: SchedulerToolPermissionMode): boolean;
+export declare function createAutomationGrantManager(options: {
+    persistence: AutomationPersistence;
+    environmentId: string;
+    availableOperations: () => Promise<readonly GrantableAutomationOperation[]>;
+    now?: () => number;
+}): {
+    get: (automationId: string) => Promise<AutomationGrantRecord | null>;
+    replace: (input: {
+        automationId: string;
+        expectedGrantRevision: number;
+        mode: SchedulerToolPermissionMode;
+        operations: readonly OperationRef[];
+        actionId: string;
+    }) => Promise<AutomationGrantRecord>;
+};
+export type AutomationGrantManager = ReturnType<typeof createAutomationGrantManager>;

package/dist/src/runtime/automations/permission-grants.js

@@ -0,0 +1,72 @@
+import { randomUUID } from "node:crypto";
+import { requireUnarchivedAutomation } from "./archive-management.js";
+export function sameOperation(left, right) {
+    return left.toolName === right.toolName &&
+        left.operationId === right.operationId &&
+        left.contractVersion === right.contractVersion;
+}
+function operationKey(ref) {
+    return `${ref.toolName}\u0000${ref.operationId}\u0000${ref.contractVersion}`;
+}
+export function currentAutomationGrant(records, environmentId, automationId) {
+    return records
+        .filter((item) => item.environmentId === environmentId && item.automationId === automationId)
+        .reduce((latest, item) => !latest || item.grantRevision > latest.grantRevision ? item : latest, null);
+}
+export function permitsAutomationOperation(grant, environmentId, automationId, selected, requiredMode) {
+    if (!grant || grant.environmentId !== environmentId || grant.automationId !== automationId)
+        return false;
+    if (requiredMode === "full_plus" && grant.mode !== "full_plus")
+        return false;
+    return grant.operations.some((operation) => sameOperation(operation, selected));
+}
+export function createAutomationGrantManager(options) {
+    const now = options.now ?? Date.now;
+    async function get(automationId) {
+        const state = await options.persistence.read();
+        return currentAutomationGrant(state.grants, options.environmentId, automationId);
+    }
+    async function replace(input) {
+        if (!Number.isSafeInteger(input.expectedGrantRevision) || input.expectedGrantRevision < 0)
+            throw new Error("automation_grant_revision_conflict");
+        if (input.mode !== "full_access" && input.mode !== "full_plus")
+            throw new Error("automation_grant_invalid");
+        if (!input.actionId || input.actionId.length > 128 || input.operations.length > 64)
+            throw new Error("automation_grant_invalid");
+        const available = await options.availableOperations();
+        const keys = new Set();
+        for (const operation of input.operations) {
+            const key = operationKey(operation);
+            const current = available.find((candidate) => sameOperation(candidate.operation, operation));
+            if (keys.has(key) || !current)
+                throw new Error("automation_operation_unavailable");
+            if (current.requiredMode === "full_plus" && input.mode !== "full_plus")
+                throw new Error("automation_grant_invalid");
+            keys.add(key);
+        }
+        return options.persistence.update((state) => {
+            if (!state.drafts.some((item) => item.automationId === input.automationId))
+                throw new Error("automation_not_found");
+            requireUnarchivedAutomation(state, input.automationId);
+            const previous = currentAutomationGrant(state.grants, options.environmentId, input.automationId);
+            if ((previous?.grantRevision ?? 0) !== input.expectedGrantRevision)
+                throw new Error("automation_grant_revision_conflict");
+            const grant = {
+                id: randomUUID(),
+                automationId: input.automationId,
+                environmentId: options.environmentId,
+                grantRevision: input.expectedGrantRevision + 1,
+                mode: input.mode,
+                operations: structuredClone(input.operations),
+                evidence: {
+                    kind: "authenticated_user_action",
+                    actionId: input.actionId,
+                    at: new Date(now()).toISOString(),
+                },
+            };
+            state.grants.push(grant);
+            return grant;
+        });
+    }
+    return { get, replace };
+}

package/dist/src/runtime/automations/persistence.d.ts

@@ -0,0 +1,9 @@
+import type { SchedulerSnapshot, SchedulerStore } from "../scheduler/contracts.js";
+import type { AutomationJournalState } from "./storage-records.js";
+/** One durable owner: this facade delegates to the scheduler journal and lease. */
+export declare function createAutomationPersistence(store: SchedulerStore): {
+    read: () => Promise<AutomationJournalState>;
+    update: <T>(mutate: (state: AutomationJournalState) => T) => Promise<T>;
+    updateWithScheduler: <T>(mutate: (scheduler: SchedulerSnapshot, automations: AutomationJournalState) => T) => Promise<T>;
+};
+export type AutomationPersistence = ReturnType<typeof createAutomationPersistence>;

package/dist/src/runtime/automations/persistence.js

@@ -0,0 +1,13 @@
+/** One durable owner: this facade delegates to the scheduler journal and lease. */
+export function createAutomationPersistence(store) {
+    const read = store.readAutomations?.bind(store);
+    const update = store.updateAutomations?.bind(store);
+    const updateWithScheduler = store.updateWithAutomations?.bind(store);
+    if (!read || !update || !updateWithScheduler)
+        throw new Error("automation_store_unavailable");
+    return {
+        read: () => read(),
+        update: (mutate) => update(mutate),
+        updateWithScheduler: (mutate) => updateWithScheduler(mutate),
+    };
+}

package/dist/src/runtime/automations/publication-validation.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeConfig } from "../ports.js";
+import type { AutomationRevision } from "./definition-contracts.js";
+import { type AutomationGraphIssue } from "./graph-validation.js";
+import type { AutomationCatalogOperation } from "./catalog.js";
+import { type AutomationScheduleTiming } from "../scheduler/automation-schedule.js";
+export declare function validateAutomationPublication(input: {
+    definition: AutomationRevision;
+    config: RuntimeConfig;
+    operations: readonly AutomationCatalogOperation[];
+    grantMode: "full_access" | "full_plus";
+    now?: number;
+    timeZone?: string;
+    /** Replaying a frozen run does not create a new scheduled occurrence. */
+    checkScheduleReadiness?: boolean;
+    existingSchedule?: AutomationScheduleTiming;
+}): readonly AutomationGraphIssue[];

package/dist/src/runtime/automations/publication-validation.js

@@ -0,0 +1,162 @@
+import { resolveModelSelection } from "../model/model-selection.js";
+import { validateToolNormalInvocationInput, validateToolNormalInvocationPayload, } from "../../capabilities/normal-invocation/validator.js";
+import { compileAutomationGraph } from "./graph-validation.js";
+import { sourceAttachmentIssue } from "./source-attachment-access.js";
+import { validateAutomationWorkingDirectory } from "./working-directory.js";
+import { normalizeAutomationSchedule, requireAutomationScheduleOccurrence, hasAutomationScheduleTimingChanged } from "../scheduler/automation-schedule.js";
+import { validateTimeZone } from "../scheduler/schedule-validation.js";
+import { SchedulerValidationError } from "../scheduler/validation-error.js";
+import { automationTriggerSchedule } from "./trigger-schedule.js";
+function validateTriggerSchedule(definition, now, timeZone, checkScheduleReadiness, existingSchedule) {
+    const trigger = definition.trigger;
+    if (trigger.kind === "manual")
+        return [];
+    if (trigger.kind !== "schedule" && trigger.kind !== "folder")
+        return [];
+    const schedule = automationTriggerSchedule(trigger);
+    try {
+        const normalized = normalizeAutomationSchedule(schedule, now, existingSchedule);
+        if (!checkScheduleReadiness)
+            return [];
+        validateTimeZone(timeZone);
+        if (!hasAutomationScheduleTimingChanged(normalized, timeZone, existingSchedule))
+            return [];
+        requireAutomationScheduleOccurrence(normalized, timeZone, now);
+        return [];
+    }
+    catch (error) {
+        if (!(error instanceof SchedulerValidationError))
+            throw error;
+        return [{ code: error.code, message: error.message,
+                path: trigger.kind === "schedule" ? "trigger.schedule" : "trigger.checkEveryMs" }];
+    }
+}
+function matchesOperation(candidate, selected) {
+    return candidate.toolName === selected.toolName &&
+        candidate.operationId === selected.operationId &&
+        candidate.contractVersion === selected.contractVersion;
+}
+function validateToolNodeInputs(node, operation) {
+    const issues = [];
+    for (const required of operation.input.required) {
+        if (!Object.hasOwn(node.controls, required))
+            issues.push({
+                code: "automation_tool_input_missing",
+                path: `nodes.${node.id}.controls.${required}`,
+                message: `Configure the required ${required} input before publishing.`,
+            });
+    }
+    const literalValues = {};
+    for (const [name, binding] of Object.entries(node.controls)) {
+        if (!Object.hasOwn(operation.input.properties, name))
+            issues.push({
+                code: "automation_tool_input_invalid",
+                path: `nodes.${node.id}.controls.${name}`,
+                message: "This input is not part of the selected operation.",
+            });
+        else if (binding.kind === "literal")
+            literalValues[name] = binding.value;
+    }
+    const contract = {
+        operationId: operation.operationId,
+        summary: operation.label,
+        input: {
+            ...operation.input,
+            required: operation.input.required.filter((name) => Object.hasOwn(literalValues, name)),
+        },
+        effect: operation.effect,
+        approval: operation.approval,
+        ...(operation.payload ? { payload: operation.payload } : {}),
+    };
+    const literalInput = validateToolNormalInvocationInput(contract, literalValues);
+    if (!literalInput.ok)
+        issues.push({
+            code: "automation_tool_input_invalid",
+            path: `nodes.${node.id}.controls`,
+            message: literalInput.issue,
+        });
+    if (operation.payload?.minBytes && !node.payload)
+        issues.push({
+            code: "automation_tool_input_missing",
+            path: `nodes.${node.id}.payload`,
+            message: "Configure the required text input before publishing.",
+        });
+    if (node.payload?.kind === "literal") {
+        const payloadIssue = validateToolNormalInvocationPayload(contract, node.payload.value);
+        if (payloadIssue)
+            issues.push({
+                code: "automation_tool_input_invalid",
+                path: `nodes.${node.id}.payload`,
+                message: payloadIssue,
+            });
+    }
+    return issues;
+}
+export function validateAutomationPublication(input) {
+    const workingDirectoryIssue = validateAutomationWorkingDirectory(input.definition.workingDirectory);
+    if (workingDirectoryIssue)
+        return [workingDirectoryIssue];
+    const compiled = compileAutomationGraph(input.definition);
+    if (!compiled.ok)
+        return compiled.issues;
+    const issues = validateTriggerSchedule(input.definition, input.now ?? Date.now(), input.timeZone ?? "UTC", input.checkScheduleReadiness !== false, input.existingSchedule);
+    let sourceMayReceiveGeneratedFiles = false;
+    if (input.definition.trigger.kind !== "manual" && input.definition.trigger.kind !== "schedule" &&
+        input.definition.trigger.kind !== "folder") {
+        issues.push({ code: "automation_graph_invalid", path: "trigger", message: "Choose a supported trigger." });
+    }
+    for (const step of compiled.graph.steps) {
+        const node = step.node;
+        const sourceIssue = sourceAttachmentIssue(node, input.operations);
+        if (sourceIssue)
+            issues.push({
+                code: sourceIssue,
+                path: `nodes.${node.id}.${node.kind === "agent" ? "inputs" : "controls"}`,
+                message: "Select an operation that accepts frozen source files, or remove this snapshot binding.",
+            });
+        const selections = node.kind === "tool"
+            ? [node.operation]
+            : node.tools.map((tool) => tool.operation);
+        for (const [index, selected] of selections.entries()) {
+            const operation = input.operations.find((entry) => matchesOperation(entry, selected));
+            const path = node.kind === "tool"
+                ? `nodes.${node.id}.operation`
+                : `nodes.${node.id}.tools.${index}`;
+            if (!operation) {
+                issues.push({ code: "automation_operation_unavailable", path, message: "Grant and configure this operation before publishing." });
+                continue;
+            }
+            if (node.kind === "tool")
+                issues.push(...validateToolNodeInputs(node, operation));
+            if (operation.effect !== "read_only")
+                sourceMayReceiveGeneratedFiles = true;
+            if (operation.approval === "always" && input.grantMode !== "full_plus") {
+                issues.push({ code: "automation_approval_required", path, message: "This operation needs an interactive approval in Full mode." });
+            }
+        }
+        if (node.kind !== "agent")
+            continue;
+        const selection = resolveModelSelection({
+            agentMode: node.agentMode,
+            modelPreference: { profileId: node.modelProfileId, scope: "all" },
+            modelPolicy: input.config.models,
+            modelExecutionPolicies: input.config.modelExecutionPolicies,
+        });
+        if (selection.execution.primaryProfileId !== node.modelProfileId) {
+            issues.push({
+                code: "automation_model_unavailable",
+                path: `nodes.${node.id}.modelProfileId`,
+                message: "The selected model profile is not available for this Agent.",
+            });
+        }
+    }
+    if (input.definition.source && sourceMayReceiveGeneratedFiles &&
+        input.definition.source.excludePatterns.length === 0) {
+        issues.push({
+            code: "automation_source_exclusions_required",
+            path: "source.excludePatterns",
+            message: "Exclude output and archive paths so generated files do not re-enter this folder workflow.",
+        });
+    }
+    return issues;
+}

package/dist/src/runtime/automations/publication.d.ts

@@ -0,0 +1,33 @@
+import type { RuntimeConfig, ToolRegistry } from "../ports.js";
+import type { SchedulerService } from "../scheduler/contracts.js";
+import type { AutomationDraftManager } from "./draft-management.js";
+import type { AutomationPersistence } from "./persistence.js";
+import type { AutomationGrantManager } from "./permission-grants.js";
+import type { AutomationGraphIssue } from "./graph-validation.js";
+export declare class AutomationPublicationError extends Error {
+    readonly issues: readonly AutomationGraphIssue[];
+    constructor(issues: readonly AutomationGraphIssue[]);
+}
+export declare function createAutomationPublicationService(options: {
+    config: RuntimeConfig;
+    drafts: AutomationDraftManager;
+    grants: AutomationGrantManager;
+    persistence: AutomationPersistence;
+    scheduler: SchedulerService;
+    tools: ToolRegistry;
+    timeZone: string;
+    now?: () => number;
+}): {
+    publish: (automationId: string, expectedRevision: number) => Promise<{
+        definition: Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("./definition-contracts.js").AutomationRevision;
+            publishedAt: string;
+            dependencyFingerprint?: string;
+        }>;
+        job: import("../scheduler/contracts.js").SchedulerAutomationJob;
+    }>;
+};
+export type AutomationPublicationService = ReturnType<typeof createAutomationPublicationService>;