@aventara/core 0.1.0-pilot.4 → 1.0.0-rc.1

package/dist/operations/structural-limits.walker.js

@@ -0,0 +1,489 @@
+import { lookupField, lookupResource } from "../contracts/contract-lookup.js";
+import { advertisedDirectives, holdsAt, } from "../contracts/field.js";
+import { NESTED_PROJECTION_SCOPE, resolveProjectionScope, } from "./projection-scope.resolver.js";
+const UNTRACKED = [];
+const RELATION_FILTER_OPERATORS = ["some", "every", "none"];
+const DIRECTIVE_PAYLOADS = new Map([
+    ["$connectOrCreate", [["create", "create"]]],
+    ["$update", [["data", "update"]]],
+    [
+        "$upsert",
+        [
+            ["create", "create"],
+            ["update", "update"],
+        ],
+    ],
+]);
+const NO_PAYLOADS = [];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extend(state, path, segment) {
+    return state.tracking ? [...path, segment] : UNTRACKED;
+}
+function nestingExceeded(state) {
+    state.nesting = {
+        path: ["arguments", state.rootKey],
+        code: "V1013",
+        message: `Request nesting exceeds maxNestingDepth (${state.nestingLimit}).`,
+    };
+}
+function jsonDepthExceeded(state, fieldPath) {
+    state.nestingAtField = true;
+    state.nesting = {
+        path: state.tracking ? fieldPath : ["arguments", state.rootKey],
+        code: "V1021",
+        message: `Json value depth exceeds maxJsonDepth (${state.jsonDepthLimit}).`,
+    };
+}
+function isJsonField(field) {
+    return "scalar" in field.type && field.type.scalar === "json";
+}
+function jsonValueExceeds(state, value) {
+    const deepest = new Map();
+    const ancestors = new Set();
+    const stack = [{ leave: false, value, level: 0 }];
+    while (stack.length > 0) {
+        const task = stack.pop();
+        if (task.leave) {
+            ancestors.delete(task.container);
+            continue;
+        }
+        const current = task.value;
+        if (typeof current !== "object" ||
+            current === null ||
+            ancestors.has(current)) {
+            continue;
+        }
+        const inner = task.level + 1;
+        if (inner > state.jsonDepthLimit) {
+            return true;
+        }
+        const seen = deepest.get(current);
+        if (seen !== undefined && seen >= inner) {
+            continue;
+        }
+        deepest.set(current, inner);
+        ancestors.add(current);
+        stack.push({ leave: true, container: current });
+        const entries = Array.isArray(current)
+            ? current
+            : Object.values(current);
+        for (const entry of entries) {
+            stack.push({ leave: false, value: entry, level: inner });
+        }
+    }
+    return false;
+}
+function walkJsonWrite(state, field, value, path) {
+    const operands = isRecord(value) && Object.keys(value).some((key) => key.startsWith("$"))
+        ? Object.entries(value)
+            .filter(([key]) => key !== "$unset" && key !== "$ref")
+            .map(([, operand]) => operand)
+        : [value];
+    for (const operand of operands) {
+        const values = field.list && Array.isArray(operand) ? operand : [operand];
+        for (const entry of values) {
+            if (jsonValueExceeds(state, entry)) {
+                jsonDepthExceeded(state, path);
+                return;
+            }
+        }
+    }
+}
+const JSON_LIST_OPERATORS = new Set(["in", "notIn", "hasEvery", "hasSome"]);
+const JSON_VALUELESS_OPERATORS = new Set(["mode", "isEmpty", "path"]);
+function walkJsonFilter(state, filter, depth, path) {
+    let level = depth;
+    let current = filter;
+    while (isRecord(current)) {
+        let next;
+        for (const operator of Object.keys(current)) {
+            const operand = current[operator];
+            if (operator === "not" && isRecord(operand)) {
+                next = operand;
+                continue;
+            }
+            if (JSON_VALUELESS_OPERATORS.has(operator)) {
+                continue;
+            }
+            const values = JSON_LIST_OPERATORS.has(operator) && Array.isArray(operand)
+                ? operand
+                : [operand];
+            for (const entry of values) {
+                if (jsonValueExceeds(state, entry)) {
+                    jsonDepthExceeded(state, path);
+                    return;
+                }
+            }
+        }
+        if (next === undefined) {
+            return;
+        }
+        level += 1;
+        if (level > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        current = next;
+    }
+    if (jsonValueExceeds(state, current)) {
+        jsonDepthExceeded(state, path);
+    }
+}
+function countBooleanNode(state, path, key) {
+    if (state.booleanExceeded) {
+        return;
+    }
+    state.booleanCount += 1;
+    if (state.booleanCount > state.booleanLimit) {
+        state.booleanExceeded = true;
+        if (state.tracking) {
+            state.booleanNodes = {
+                path: [...path, key],
+                code: "V1015",
+                message: `Boolean/filter node count exceeds maxBooleanNodes (${state.booleanLimit}).`,
+            };
+        }
+    }
+}
+function walkWhere(state, resourceName, value, depth, path, counting) {
+    if (depth > state.nestingLimit) {
+        nestingExceeded(state);
+        return;
+    }
+    const resource = lookupResource(state.contract, resourceName);
+    if (!isRecord(value) || resource === undefined) {
+        return;
+    }
+    for (const key of Object.keys(value)) {
+        if (counting) {
+            countBooleanNode(state, path, key);
+        }
+        const child = value[key];
+        if (key === "AND" || key === "OR") {
+            if (Array.isArray(child)) {
+                for (let index = 0; index < child.length; index += 1) {
+                    walkWhere(state, resourceName, child[index], depth + 1, state.tracking ? [...path, key, index] : UNTRACKED, counting);
+                    if (state.nesting !== undefined) {
+                        return;
+                    }
+                }
+            }
+            continue;
+        }
+        if (key === "NOT") {
+            walkWhere(state, resourceName, child, depth + 1, extend(state, path, key), counting);
+        }
+        else {
+            const field = lookupField(resource, key);
+            if (field?.kind === "scalar") {
+                if (isJsonField(field)) {
+                    walkJsonFilter(state, child, depth, extend(state, path, key));
+                }
+                else {
+                    walkScalarNot(state, child, depth);
+                }
+            }
+            if (field?.kind !== "relation") {
+                if (state.nesting !== undefined) {
+                    return;
+                }
+                continue;
+            }
+            if (field.cardinality === "one") {
+                walkWhere(state, field.target, child, depth + 1, extend(state, path, key), counting);
+            }
+            else if (isRecord(child)) {
+                for (const operator of RELATION_FILTER_OPERATORS) {
+                    if (!(operator in child)) {
+                        continue;
+                    }
+                    walkWhere(state, field.target, child[operator], depth + 1, state.tracking ? [...path, key, operator] : UNTRACKED, counting);
+                    if (state.nesting !== undefined) {
+                        return;
+                    }
+                }
+            }
+        }
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function walkScalarNot(state, filter, depth) {
+    let level = depth;
+    let current = filter;
+    while (isRecord(current) && Object.hasOwn(current, "not")) {
+        const operand = current.not;
+        if (!isRecord(operand)) {
+            return;
+        }
+        level += 1;
+        if (level > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        current = operand;
+    }
+}
+function walkOrderBy(state, resourceName, value, depth) {
+    const resource = lookupResource(state.contract, resourceName);
+    if (resource === undefined) {
+        return;
+    }
+    const entries = Array.isArray(value) ? value : [value];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (!isRecord(entry)) {
+            continue;
+        }
+        for (const fieldName of Object.keys(entry)) {
+            const field = lookupField(resource, fieldName);
+            if (field?.kind !== "relation" || field.cardinality === "many") {
+                continue;
+            }
+            const relationDepth = depth + 1;
+            if (relationDepth > state.nestingLimit) {
+                nestingExceeded(state);
+                return;
+            }
+            walkOrderBy(state, field.target, entry[fieldName], relationDepth);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+}
+function soleKey(record) {
+    const keys = Object.keys(record);
+    return keys.length === 1 ? keys[0] : undefined;
+}
+function walkProjection(state, resourceName, value, depth, path, mode, scope) {
+    const resource = lookupResource(state.contract, resourceName);
+    if (!Array.isArray(value) || resource === undefined) {
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const entry = value[index];
+        const relationName = isRecord(entry) ? soleKey(entry) : undefined;
+        const edge = relationName === undefined
+            ? undefined
+            : lookupField(resource, relationName);
+        if (relationName === undefined || edge?.kind !== "relation") {
+            continue;
+        }
+        const relationDepth = depth + 1;
+        if (relationDepth > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        const projection = entry[relationName];
+        if (!isRecord(projection)) {
+            continue;
+        }
+        const relationPath = state.tracking
+            ? [...path, index, relationName]
+            : UNTRACKED;
+        const counted = scope !== undefined &&
+            holdsAt(mode === "select"
+                ? edge.capabilities.select
+                : edge.capabilities.include, scope);
+        if ("where" in projection) {
+            walkWhere(state, edge.target, projection.where, relationDepth, extend(state, relationPath, "where"), counted && edge.capabilities.filter?.includes("nested") === true);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+        if ("orderBy" in projection) {
+            walkOrderBy(state, edge.target, projection.orderBy, relationDepth);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+        for (const nestedMode of ["select", "include"]) {
+            if (!(nestedMode in projection)) {
+                continue;
+            }
+            walkProjection(state, edge.target, projection[nestedMode], relationDepth, extend(state, relationPath, nestedMode), nestedMode, counted ? NESTED_PROJECTION_SCOPE : undefined);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+}
+function walkMutationData(state, resourceName, value, depth, path, stage, counting) {
+    if (depth > state.nestingLimit) {
+        nestingExceeded(state);
+        return;
+    }
+    const resource = lookupResource(state.contract, resourceName);
+    if (!isRecord(value) || resource === undefined) {
+        return;
+    }
+    for (const fieldName of Object.keys(value)) {
+        const edge = lookupField(resource, fieldName);
+        const directives = value[fieldName];
+        if (edge?.kind === "scalar" && isJsonField(edge)) {
+            walkJsonWrite(state, edge, directives, extend(state, path, fieldName));
+            if (state.nesting !== undefined) {
+                return;
+            }
+            continue;
+        }
+        if (edge?.kind !== "relation" || !isRecord(directives)) {
+            continue;
+        }
+        walkRelationDirectives(state, edge, directives, depth + 1, extend(state, path, fieldName), stage, counting);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function walkRelationDirectives(state, edge, directives, relationDepth, path, stage, counting) {
+    const supported = advertisedDirectives(edge.capabilities[stage]);
+    for (const directive of Object.keys(directives)) {
+        if (relationDepth > state.nestingLimit) {
+            nestingExceeded(state);
+            return;
+        }
+        const directivePath = extend(state, path, directive);
+        const directiveCounting = counting && supported?.includes(directive) === true;
+        const directiveValue = directives[directive];
+        if (Array.isArray(directiveValue)) {
+            for (let index = 0; index < directiveValue.length; index += 1) {
+                walkDirectiveEntry(state, edge.target, directive, directiveValue[index], relationDepth, extend(state, directivePath, index), directiveCounting);
+                if (state.nesting !== undefined) {
+                    return;
+                }
+            }
+        }
+        else {
+            walkDirectiveEntry(state, edge.target, directive, directiveValue, relationDepth, directivePath, directiveCounting);
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+}
+function walkDirectiveEntry(state, target, directive, entry, relationDepth, path, counting) {
+    if (directive === "$create") {
+        walkMutationData(state, target, entry, relationDepth, path, "create", counting);
+        return;
+    }
+    if (!isRecord(entry)) {
+        return;
+    }
+    if ((directive === "$update" || directive === "$delete") &&
+        "where" in entry) {
+        walkWhere(state, target, entry.where, relationDepth, extend(state, path, "where"), counting);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    for (const [key, stage] of DIRECTIVE_PAYLOADS.get(directive) ?? NO_PAYLOADS) {
+        if (!(key in entry)) {
+            continue;
+        }
+        walkMutationData(state, target, entry[key], relationDepth, extend(state, path, key), stage, counting);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function isUniqueOperation(request) {
+    return (request.variant === "unique" &&
+        (request.family === "find" ||
+            request.family === "update" ||
+            request.family === "delete" ||
+            request.family === "upsert"));
+}
+function walkArguments(state, request, args) {
+    const resource = request.resource;
+    const rootPath = (key) => {
+        state.rootKey = key;
+        return state.tracking ? ["arguments", key] : UNTRACKED;
+    };
+    if ("where" in args) {
+        walkWhere(state, resource, args.where, 1, rootPath("where"), !isUniqueOperation(request));
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    if ("orderBy" in args) {
+        rootPath("orderBy");
+        walkOrderBy(state, resource, args.orderBy, 0);
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    for (const mode of ["select", "include"]) {
+        if (!(mode in args)) {
+            continue;
+        }
+        walkProjection(state, resource, args[mode], 0, rootPath(mode), mode, resolveProjectionScope(lookupResource(state.contract, resource), request));
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+    if ("data" in args) {
+        const path = rootPath("data");
+        const data = args.data;
+        if (Array.isArray(data)) {
+            for (let index = 0; index < data.length; index += 1) {
+                walkMutationData(state, resource, data[index], 0, extend(state, path, index), "create", request.family === "create");
+                if (state.nesting !== undefined) {
+                    return;
+                }
+            }
+        }
+        else {
+            walkMutationData(state, resource, data, 0, path, request.family === "update" ? "update" : "create", request.family === "create" || request.family === "update");
+            if (state.nesting !== undefined) {
+                return;
+            }
+        }
+    }
+    for (const branch of ["create", "update"]) {
+        if (!(branch in args)) {
+            continue;
+        }
+        walkMutationData(state, resource, args[branch], 0, rootPath(branch), branch, request.family === "upsert");
+        if (state.nesting !== undefined) {
+            return;
+        }
+    }
+}
+function walk(contract, request, args, tracking) {
+    const state = {
+        contract,
+        nestingLimit: contract.limits.maxNestingDepth,
+        jsonDepthLimit: contract.limits.maxJsonDepth,
+        booleanLimit: contract.limits.maxBooleanNodes,
+        tracking,
+        rootKey: "",
+        booleanCount: 0,
+        nesting: undefined,
+        nestingAtField: false,
+        booleanNodes: undefined,
+        booleanExceeded: false,
+    };
+    walkArguments(state, request, args);
+    return state;
+}
+export function findStructuralLimitIssues(contract, request, args) {
+    const untracked = walk(contract, request, args, false);
+    if (untracked.nestingAtField) {
+        return {
+            nesting: walk(contract, request, args, true).nesting,
+            booleanNodes: undefined,
+        };
+    }
+    if (untracked.nesting !== undefined || !untracked.booleanExceeded) {
+        return { nesting: untracked.nesting, booleanNodes: undefined };
+    }
+    return {
+        nesting: undefined,
+        booleanNodes: walk(contract, request, args, true).booleanNodes,
+    };
+}

package/dist/operations/validation-code.d.ts

@@ -1,14 +1,19 @@
+import type { AvFieldCheck } from "../contracts/field-check.js";
 /** The set of allocated Validation codes, as a runtime array. */
-export declare const VALIDATION_CODES: readonly ["V1000", "V1001", "V1002", "V1003", "V1004", "V1005", "V1006", "V1007", "V1008", "V1009", "V1010", "V1011", "V1012", "V1013", "V1014", "V1015", "V1016", "V1017", "V1018", "V1019"];
+export declare const VALIDATION_CODES: readonly ["V1000", "V1001", "V1002", "V1003", "V1004", "V1005", "V1006", "V1007", "V1008", "V1009", "V1010", "V1011", "V1012", "V1013", "V1014", "V1015", "V1016", "V1017", "V1018", "V1019", "V1020", "V1021"];
 /** A validation code (`V1000` and up), one per kind of argument problem. */
-export type ValidationCode = (typeof VALIDATION_CODES)[number];
+export type AvValidationCode = (typeof VALIDATION_CODES)[number];
 /** The framework's message for each validation code. */
-export declare const VALIDATION_CODE_MESSAGES: Readonly<Record<ValidationCode, string>>;
+export declare const VALIDATION_CODE_MESSAGES: Readonly<Record<AvValidationCode, string>>;
 /** One validation problem: its code, message and the argument path it is at. */
-export type ValidationIssue = {
+export type AvValidationIssue = {
     readonly path?: readonly (string | number)[];
-    readonly code: ValidationCode;
+    readonly code: AvValidationCode;
     readonly message: string;
+    /** The failed field validator's check name (`max_length`, `string_format`, …). */
+    readonly check?: AvFieldCheck["check"];
+    /** That check's parameters, as the Contract stores them (`{ maximum: 80 }`). */
+    readonly params?: Readonly<Record<string, unknown>>;
 };
 /** Builds one validation issue at its path. */
-export declare function validationIssue(code: ValidationCode, path: readonly (string | number)[], message: string): ValidationIssue;
+export declare function validationIssue(code: AvValidationCode, path: readonly (string | number)[], message: string): AvValidationIssue;

package/dist/operations/validation-code.js

@@ -19,6 +19,8 @@ export const VALIDATION_CODES = [
     "V1017",
     "V1018",
     "V1019",
+    "V1020",
+    "V1021",
 ];
 export const VALIDATION_CODE_MESSAGES = {
     V1000: "Required value missing.",
@@ -41,6 +43,8 @@ export const VALIDATION_CODE_MESSAGES = {
     V1017: "Transaction fingerprint mismatch.",
     V1018: "Transaction reference resolved to no value.",
     V1019: "Transaction step depends on a row removed by an earlier step's cascade",
+    V1020: "Transaction mixes application and client steps.",
+    V1021: "Json value depth limit exceeded.",
 };
 export function validationIssue(code, path, message) {
     return { code, path, message };

package/dist/operations/write-scope.resolver.d.ts

@@ -1,15 +1,15 @@
-import type { WriteScope } from "../contracts/capability.js";
-import type { Contract } from "../contracts/contract.js";
-import type { Resource } from "../contracts/resource.js";
-import type { OperationIdentity } from "./operation-identity.js";
+import type { AvWriteScope } from "../contracts/capability.js";
+import type { AvContract } from "../contracts/contract.js";
+import type { AvResource } from "../contracts/resource.js";
+import type { AvOperationIdentity } from "./operation-identity.js";
 /**
  * Which write position one request's top-level `data` (or `create`/`update`)
  * argument sits in, read off the variant the Resource advertises. `"nested"`
  * wherever nothing narrower is stated.
  */
-export declare function resolveWriteScope(resource: Resource<Contract> | undefined, request: OperationIdentity): WriteScope;
+export declare function resolveWriteScope(resource: AvResource<AvContract> | undefined, request: AvOperationIdentity): AvWriteScope;
 /**
  * The position a write NESTED beneath an admitted relation directive sits in: the
  * unrestricted one, at every depth, under every top-level scope.
  */
-export declare const NESTED_WRITE_SCOPE: WriteScope;
+export declare const NESTED_WRITE_SCOPE: AvWriteScope;

package/dist/protocol/absent-route.responder.d.ts

@@ -1,7 +1,9 @@
-import type { FrameworkContracts } from "../compiler/contract.compiler.js";
-import { type OperationIdentity } from "../operations/operation-identity.js";
+import type { AvContracts } from "../compiler/contract.compiler.js";
+import type { RemoteRequestOrigin } from "../config/config-layer.js";
+import { type AvOperationIdentity } from "../operations/operation-identity.js";
+import { type AvDiagnosticsSink } from "../runtime/diagnostics-reporter.js";
 import type { ClientProtocolIdentity } from "../runtime/operation-request.js";
-import { type OperationFailureResponse } from "../runtime/operation-response.js";
+import { type AvOperationFailureResponse } from "../runtime/operation-response.js";
 import type { AvProtocolRequest } from "./http-request.decoder.js";
 import { type ReadRequest } from "./http-request.reader.js";
 import { type AvProtocolResponse } from "./http-response.encoder.js";
@@ -22,10 +24,10 @@ export type OperationRouteSegments = {
 /** What a route check resolves to: the operation it names, or the answer that refuses it. */
 export type OperationRouteResolution = {
     readonly ok: true;
-    readonly operation: OperationIdentity;
+    readonly operation: AvOperationIdentity;
 } | {
     readonly ok: false;
-    readonly failure: OperationFailureResponse;
+    readonly failure: AvOperationFailureResponse;
 };
 /**
  * An operation route `/_resources/<resource>/<family>/<variant>` under one client
@@ -34,7 +36,7 @@ export type OperationRouteResolution = {
  * is a standard operation the Resource advertises, read through
  * `isOperationVariantAvailable` alone.
  */
-export declare function resolveOperationRoute(contracts: FrameworkContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments): OperationRouteResolution;
+export declare function resolveOperationRoute(contracts: AvContracts, protocol: ClientProtocolIdentity, route: OperationRouteSegments, origin?: RemoteRequestOrigin): OperationRouteResolution;
 /**
  * The `/_transactions` route under one client protocol identity: version → hash → the
  * ClientContract's transaction capability. The route exists only when that capability
@@ -42,7 +44,7 @@ export declare function resolveOperationRoute(contracts: FrameworkContracts, pro
  * it — and is otherwise absent with core's own refusal of a plan. `undefined` when the
  * route is there.
  */
-export declare function transactionsRouteFailure(contracts: FrameworkContracts, protocol: ClientProtocolIdentity): OperationFailureResponse | undefined;
+export declare function transactionsRouteFailure(contracts: AvContracts, protocol: ClientProtocolIdentity, origin?: RemoteRequestOrigin): AvOperationFailureResponse | undefined;
 /**
  * What a route's checks before its body resolve to: the route a request
  * reaches, or the framework response that answers it instead.
@@ -62,9 +64,9 @@ type RouteCheck<Route> = ({
  * for both route styles: `decodeOperation` reads the body only after it passes,
  * `answerAbsent` never.
  */
-export declare function checkOperationRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<{
+export declare function checkOperationRoute(contracts: AvContracts, read: ReadRequest, origin?: RemoteRequestOrigin): RouteCheck<{
     readonly resource: string;
-    readonly operation: OperationIdentity;
+    readonly operation: AvOperationIdentity;
 }>;
 /**
  * `/_transactions`' checks before its body: the path (`A2000` unless exactly
@@ -72,12 +74,12 @@ export declare function checkOperationRoute(contracts: FrameworkContracts, read:
  * {@link transactionsRouteFailure} — version, hash, `"interactive"` — and the
  * method (`A2012`, `Allow: POST`).
  */
-export declare function checkTransactionsRoute(contracts: FrameworkContracts, read: ReadRequest): RouteCheck<object>;
+export declare function checkTransactionsRoute(contracts: AvContracts, read: ReadRequest, origin?: RemoteRequestOrigin): RouteCheck<object>;
 /**
  * `protocol.answerAbsent(request)` — the fallback a host that mounts one route per
  * `protocol.surface()` entry mounts for every path it did not. Never a catch-all into
  * framework handling: it reads no body, runs no pipeline, calls no Adapter, and takes
  * only the compiled Contracts. In order:
  */
-export declare function answerAbsentRequest(contracts: FrameworkContracts, received: AvProtocolRequest): AvProtocolResponse | undefined;
+export declare function answerAbsentRequest(contracts: AvContracts, received: AvProtocolRequest, sink?: AvDiagnosticsSink, origin?: RemoteRequestOrigin): AvProtocolResponse | undefined;
 export {};