@aventara/core 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/compiler/contract.compiler.js

@@ -1,5 +1,5 @@
 import { bindShapedField, jsonShapeOf } from "../avz/json-shape.registry.js";
-import { PROJECTION_SCOPES, WRITE_SCOPES } from "../contracts/capability.js";
+import { FILTER_MODES, PROJECTION_SCOPES, WRITE_SCOPES, } from "../contracts/capability.js";
 import { validateClientContractStructure } from "../contracts/client-contract-structure.validator.js";
 import { canonicalizeContract, canonicalizeContractMembers, canonicalizeJson, joinCanonicalContractMembers, recordCanonicalContractText, } from "../contracts/contract-canonicalizer.js";
 import { hashCanonicalContractText, } from "../contracts/contract-hash.js";
@@ -7,8 +7,10 @@ import { DEFAULT_CONTRACT_LIMITS, } from "../contracts/contract-limits.js";
 import { AVENTARA_PROTOCOL_VERSION } from "../contracts/contract-protocol.js";
 import { advertisedDirectives, advertisedReducers, holdsInAnyScope, } from "../contracts/field.js";
 import { isOperationVariantAvailable, } from "../contracts/resource-operations.js";
+import { isRecord } from "../runtime/record.guard.js";
 import { checkCreateRequirements, checkHiddenRequirements, projectCreateRequirements, } from "./create-requirements.projector.js";
 import { applyValidators, bindFieldValidators, checkLayerValidators, compileValidatorTable, } from "./field-validator.compiler.js";
+import { explainManagedRefusals, hideManagedElsewhere, managedElsewhereOf, managedWriteReason, markCoreResources, pruneManagedEnums, withholdManagedWrites, } from "./managed-elsewhere.projector.js";
 const UNIQUE_VARIANTS = [
     ["find", "unique"],
     ["update", "unique"],
@@ -23,9 +25,6 @@ const COMPUTED_TRAITS = new Set([
 function diagnostic(code, path, message) {
     return { code, path, message };
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 function cloneValue(value) {
     if (Array.isArray(value)) {
         return value.map((entry) => cloneValue(entry));
@@ -41,6 +40,12 @@ function normalizeAdapterScalarCapabilities(capabilities) {
         ...(capabilities.filter !== undefined
             ? { filter: [...capabilities.filter] }
             : {}),
+        ...(capabilities.filterModes !== undefined
+            ? { filterModes: [...capabilities.filterModes] }
+            : {}),
+        ...(capabilities.pathFilterModes !== undefined
+            ? { pathFilterModes: [...capabilities.pathFilterModes] }
+            : {}),
         ...(capabilities.order !== undefined ? { order: capabilities.order } : {}),
         ...(capabilities.orderNulls !== undefined
             ? { orderNulls: capabilities.orderNulls }
@@ -71,8 +76,65 @@ function cloneAdapterField(field) {
         cardinality: field.cardinality,
         nullable: field.nullable,
         capabilities: cloneValue(field.capabilities),
+        ...(typeof field.inverse === "string" ? { inverse: field.inverse } : {}),
+        ...(Array.isArray(field.referenceFields) && field.referenceFields.length > 0
+            ? { referenceFields: [...field.referenceFields] }
+            : {}),
+        ...(Array.isArray(field.referenceFields) &&
+            Array.isArray(field.references) &&
+            field.references.length > 0 &&
+            field.references.length === field.referenceFields.length
+            ? { references: [...field.references] }
+            : {}),
     };
 }
+function pruneHiddenPairings(projection, references) {
+    const resources = projection.resources;
+    for (const [name, resource] of Object.entries(resources)) {
+        for (const field of Object.values(resource.fields)) {
+            if (field.kind !== "relation") {
+                continue;
+            }
+            if (Array.isArray(field.references) &&
+                (references === "none" ||
+                    !wholePairing(resource.fields, Object.hasOwn(resources, String(field.target))
+                        ? resources[String(field.target)]?.fields
+                        : undefined, field.referenceFields, field.references))) {
+                delete field.references;
+            }
+            if (Array.isArray(field.referenceFields)) {
+                const shown = field.referenceFields.filter((reference) => typeof reference === "string" &&
+                    Object.hasOwn(resource.fields, reference) &&
+                    resource.fields[reference]?.kind === "scalar");
+                if (shown.length > 0) {
+                    field.referenceFields = shown;
+                }
+                else {
+                    delete field.referenceFields;
+                }
+            }
+            if (typeof field.inverse !== "string") {
+                continue;
+            }
+            const other = Object.hasOwn(resources, String(field.target))
+                ? resources[String(field.target)]?.fields[field.inverse]
+                : undefined;
+            if (other?.kind !== "relation" || other.target !== name) {
+                delete field.inverse;
+            }
+        }
+    }
+}
+function wholePairing(fields, targetFields, referenceFields, references) {
+    const shownIn = (within, name) => typeof name === "string" &&
+        within !== undefined &&
+        Object.hasOwn(within, name) &&
+        within[name]?.kind === "scalar";
+    return (Array.isArray(referenceFields) &&
+        referenceFields.length === references.length &&
+        referenceFields.every((name) => shownIn(fields, name)) &&
+        references.every((name) => shownIn(targetFields, name)));
+}
 function cloneOperations(operations) {
     return cloneValue(operations);
 }
@@ -86,8 +148,40 @@ function cloneAdapterResource(resource) {
         operations: cloneOperations(resource.operations),
     };
 }
+function canonicalModes(modes) {
+    const stated = Array.isArray(modes) ? modes : [];
+    const known = FILTER_MODES.filter((mode) => mode === "default" || stated.includes(mode));
+    const unknown = stated.filter((mode) => !FILTER_MODES.includes(mode));
+    return [...known, ...unknown];
+}
+function qualifyFilterModes(projection) {
+    for (const resource of Object.values(projection.resources)) {
+        for (const field of Object.values(resource.fields)) {
+            if (field.kind !== "scalar") {
+                continue;
+            }
+            const capabilities = field.capabilities;
+            const filter = Array.isArray(capabilities.filter)
+                ? capabilities.filter
+                : [];
+            if (!filter.includes("mode")) {
+                delete capabilities.filterModes;
+                delete capabilities.pathFilterModes;
+                continue;
+            }
+            const stated = capabilities.filterModes;
+            capabilities.filterModes = canonicalModes(stated);
+            if (filter.includes("path")) {
+                capabilities.pathFilterModes = canonicalModes(capabilities.pathFilterModes ?? stated);
+            }
+            else {
+                delete capabilities.pathFilterModes;
+            }
+        }
+    }
+}
 function createBaseline(model) {
-    return {
+    const baseline = {
         scalars: Object.fromEntries(Object.entries(model.scalars).map(([key, value]) => [
             key,
             cloneValue(value),
@@ -106,6 +200,8 @@ function createBaseline(model) {
             ? {}
             : { referenceWrites: model.referenceWrites }),
     };
+    qualifyFilterModes(baseline);
+    return baseline;
 }
 function definitionPath(resource, field) {
     return `root.resources.${resource}.fields.${field}.definition`;
@@ -285,7 +381,7 @@ function checkFieldCompute(model, resourceName, fieldName, field, compute, path,
         }
     }
 }
-function checkResourceTree(model, baseline, scope, tree, definitions, diagnostics) {
+function checkResourceTree(model, baseline, scope, tree, definitions, managed, diagnostics) {
     if (!isRecord(tree)) {
         return;
     }
@@ -296,12 +392,22 @@ function checkResourceTree(model, baseline, scope, tree, definitions, diagnostic
             diagnostics.push(diagnostic("COMPILER_UNKNOWN_RESOURCE", resourcePath, `resource "${resourceName}" is not present in the canonical adapter model`));
             continue;
         }
+        if ((scope === "client" || scope === "agent") &&
+            managed.has(resourceName)) {
+            diagnostics.push(diagnostic("COMPILER_UNKNOWN_RESOURCE", resourcePath, `resource "${resourceName}" is managed elsewhere (resources.${resourceName}.managedElsewhere), so the ${scope} layer never has it: nothing configured for it here runs`));
+            continue;
+        }
         if (!isRecord(entry)) {
             continue;
         }
         if (isRecord(entry.operations)) {
             for (const [family, level] of Object.entries(entry.operations)) {
                 const familyPath = `${resourcePath}.operations.${family}`;
+                const managedReason = managedWriteReason(managed, resourceName, family);
+                if (managedReason !== undefined) {
+                    diagnostics.push(diagnostic("COMPILER_UNAVAILABLE_OPERATION", familyPath, managedReason));
+                    continue;
+                }
                 const variants = resource.operations[family];
                 if (!isRecord(variants)) {
                     diagnostics.push(diagnostic("COMPILER_UNAVAILABLE_OPERATION", familyPath, `operation family "${family}" is not available for resource "${resourceName}"`));
@@ -330,7 +436,8 @@ function checkResourceTree(model, baseline, scope, tree, definitions, diagnostic
                 diagnostics.push(diagnostic("COMPILER_UNKNOWN_FIELD", `${resourcePath}.fields.${fieldName}`, `field "${fieldName}" is neither discovered by the adapter nor defined at the root`));
                 continue;
             }
-            if (!isRecord(fieldEntry) || !isRecord(fieldEntry.pipelines)) {
+            if (!isRecord(fieldEntry) ||
+                !isRecord(fieldEntry.pipelines)) {
                 continue;
             }
             const pipelinesPath = `${resourcePath}.fields.${fieldName}.pipelines`;
@@ -349,9 +456,14 @@ function checkReservedResourceNames(model, diagnostics) {
         }
     }
 }
+function isAdapterStated(axis) {
+    return axis?.kind === "limit" || axis?.kind === "adapterTokens";
+}
 const SCALAR_CAPABILITY_AXES = {
     select: { kind: "flag" },
     filter: { kind: "tokens" },
+    filterModes: { kind: "adapterTokens", values: FILTER_MODES },
+    pathFilterModes: { kind: "adapterTokens", values: FILTER_MODES },
     order: { kind: "flag" },
     orderNulls: { kind: "flag" },
     create: { kind: "tokens" },
@@ -445,11 +557,11 @@ function fieldName(resource, field) {
 }
 function exemptableAxis(walk, universeField, capability, label, path) {
     const axis = capabilityAxisFor(universeField.kind, capability);
-    if (axis === undefined || axis.kind === "limit") {
+    if (axis === undefined || isAdapterStated(axis)) {
         const names = Object.entries(universeField.kind === "scalar"
             ? SCALAR_CAPABILITY_AXES
             : RELATION_CAPABILITY_AXES)
-            .filter(([, entry]) => entry.kind !== "limit")
+            .filter(([, entry]) => !isAdapterStated(entry))
             .map(([name]) => name);
         unavailableCapability(path, `"${capability}" is not a capability a ${universeField.kind} field's exemption can name; it takes ${names.join(", ")}`, walk.diagnostics);
         return undefined;
@@ -533,7 +645,7 @@ function exemptField(walk, universeField, parentField, entry, label, path) {
     const result = walk.style === "omit" ? cloneValue(parentCapabilities) : {};
     if (walk.style === "pick") {
         for (const [key, value] of Object.entries(parentCapabilities)) {
-            if (capabilityAxisFor(universeField.kind, key)?.kind === "limit") {
+            if (isAdapterStated(capabilityAxisFor(universeField.kind, key))) {
                 result[key] = cloneValue(value);
             }
         }
@@ -552,7 +664,7 @@ function exemptField(walk, universeField, parentField, entry, label, path) {
         return undefined;
     }
     if (walk.style === "pick" &&
-        !Object.keys(result).some((key) => capabilityAxisFor(universeField.kind, key)?.kind !== "limit")) {
+        !Object.keys(result).some((key) => !isAdapterStated(capabilityAxisFor(universeField.kind, key)))) {
         return undefined;
     }
     return { ...cloneValue(parentField), capabilities: result };
@@ -651,7 +763,9 @@ function exemptOperations(walk, resourceName, universe, parent, entry, path) {
         if (value === false || value === undefined) {
             continue;
         }
-        if (value !== true && !Array.isArray(value) && !isRecord(value)) {
+        if (value !== true &&
+            !Array.isArray(value) &&
+            !isRecord(value)) {
             walk.diagnostics.push(diagnostic("COMPILER_UNAVAILABLE_OPERATION", familyPath, "an operation family takes true, false, a list of its variants or an object of them"));
             continue;
         }
@@ -698,7 +812,8 @@ function exemptResource(walk, resourceName, universe, parent, entry, path) {
 }
 function projectExposure(walk, universe, parent, exemptions) {
     const path = `${walk.layer}.exemptions.resources`;
-    const entries = isRecord(exemptions) && isRecord(exemptions.resources)
+    const entries = isRecord(exemptions) &&
+        isRecord(exemptions.resources)
         ? exemptions.resources
         : {};
     const resources = {};
@@ -742,7 +857,8 @@ function projectExposure(walk, universe, parent, exemptions) {
 }
 function pruneEmptyOperationFamilies(operations) {
     for (const [family, variants] of Object.entries(operations)) {
-        if (isRecord(variants) && Object.keys(variants).length === 0) {
+        if (isRecord(variants) &&
+            Object.keys(variants).length === 0) {
             delete operations[family];
         }
     }
@@ -839,6 +955,11 @@ function representationFault(axis, value) {
             return typeof value === "string" && axis.values.includes(value)
                 ? undefined
                 : `one of ${axis.values.join(", ")} is expected`;
+        case "adapterTokens":
+            return isTokenList(value) &&
+                value.every((token) => axis.values.includes(token))
+                ? undefined
+                : `a list of ${axis.values.join(", ")} is expected`;
         case "flag":
             return typeof value === "boolean" ? undefined : "a boolean is expected";
         case "tokens":
@@ -912,35 +1033,71 @@ function exposureStyle(layer) {
 }
 function projectCore(model, config, diagnostics) {
     const scope = config.root;
+    const managed = managedElsewhereOf(config.trees.root);
     const providerBaseline = createBaseline(model);
     const baseline = cloneValue(providerBaseline);
     baseline.limits = resolveLimits(scope);
     baseline.transactions = resolveTransactions(model, "root", scope, diagnostics);
-    checkResourceTree(model, baseline, "root", config.trees.root, config.definitions, diagnostics);
+    checkResourceTree(model, baseline, "root", config.trees.root, config.definitions, managed, diagnostics);
     applyFieldDefinitions(model, baseline, config.definitions, diagnostics);
+    const unwithheld = managed.size === 0 ? baseline : cloneValue(baseline);
+    withholdManagedWrites(baseline, managed);
+    markGovernedFields(baseline, config.policy?.governed);
     applyCompute(baseline, scope.compute);
     checkLayerValidators(baseline.resources, "root", config.trees.root, diagnostics);
     const validators = compileValidatorTable(baseline.resources, scope.pipelines);
     const projection = projectExposure({ layer: "root", style: exposureStyle(scope), diagnostics }, baseline, baseline, scope.exemptions);
+    qualifyFilterModes(projection);
+    pruneHiddenPairings(projection, "shown");
     projectCreateRequirements(model, projection.resources);
-    checkHiddenRequirements(model, "root", baseline.resources, baseline.resources, projection.resources, diagnostics);
+    const rootChecked = diagnostics.length;
+    checkHiddenRequirements(model, "root", baseline.resources, unwithheld.resources, projection.resources, diagnostics);
+    explainManagedRefusals(diagnostics, rootChecked, "root", baseline, managed);
     applyValidators(projection.resources, validators);
     validateProjection(projection, "root", diagnostics);
     return { baseline, projection, validators };
 }
+function markGovernedFields(baseline, governed) {
+    if (governed === undefined) {
+        return;
+    }
+    for (const [resourceName, names] of Object.entries(governed)) {
+        const resource = Object.hasOwn(baseline.resources, resourceName)
+            ? baseline.resources[resourceName]
+            : undefined;
+        if (resource === undefined) {
+            continue;
+        }
+        for (const name of names) {
+            const field = Object.hasOwn(resource.fields, name)
+                ? resource.fields[name]
+                : undefined;
+            if (field !== undefined) {
+                field.governed = true;
+            }
+        }
+    }
+}
 function projectDerivedScope(model, scopeName, core, parentView, config, diagnostics) {
     const scope = config[scopeName];
+    const managed = managedElsewhereOf(config.trees.root);
     const baseline = cloneValue(core.baseline);
     baseline.limits = resolveLimits(scope);
     baseline.transactions = resolveTransactions(model, scopeName, scope, scopeName === "agent" &&
         scope.transactionsStyle === config[config.agent.parent].transactionsStyle
         ? []
         : diagnostics);
-    checkResourceTree(model, baseline, scopeName, config.trees[scopeName], config.definitions, diagnostics);
+    checkResourceTree(model, baseline, scopeName, config.trees[scopeName], config.definitions, managed, diagnostics);
     applyCompute(baseline, scope.compute);
     checkLayerValidators(baseline.resources, scopeName, config.trees[scopeName], diagnostics);
     const validators = compileValidatorTable(baseline.resources, scope.pipelines);
     const parent = cloneValue(parentView);
+    const unhidden = (scopeName === "client" || scopeName === "agent") && managed.size > 0
+        ? cloneValue(parent)
+        : parent;
+    if (unhidden !== parent) {
+        hideManagedElsewhere(parent, managed);
+    }
     parent.limits = resolveLimits(scope);
     parent.transactions = baseline.transactions;
     applyCompute(parent, scope.compute);
@@ -950,8 +1107,15 @@ function projectDerivedScope(model, scopeName, core, parentView, config, diagnos
         diagnostics,
         ...(scopeName === "agent" ? { parent: config.agent.parent } : {}),
     }, baseline, parent, scope.exemptions);
+    qualifyFilterModes(projection);
+    pruneHiddenPairings(projection, "none");
+    if (unhidden !== parent) {
+        pruneManagedEnums(projection, unhidden, managed);
+    }
     projectCreateRequirements(model, projection.resources);
-    checkHiddenRequirements(model, scopeName, baseline.resources, parent.resources, projection.resources, diagnostics);
+    const layerChecked = diagnostics.length;
+    checkHiddenRequirements(model, scopeName, baseline.resources, unhidden.resources, projection.resources, diagnostics);
+    explainManagedRefusals(diagnostics, layerChecked, scopeName, baseline, managed);
     applyValidators(projection.resources, validators);
     validateProjection(projection, scopeName, diagnostics);
     return { projection, validators };
@@ -984,12 +1148,16 @@ export async function compileContracts(model, config) {
         : agentParent === "application"
             ? applicationProjection.projection
             : clientProjection.projection, compilerConfig, diagnostics);
+    markCoreResources(coreCompilation.projection, model, managedElsewhereOf(compilerConfig.trees.root));
     if (diagnostics.length > 0) {
         return { ok: false, diagnostics };
     }
     const core = semanticObject(coreCompilation.projection);
     const application = semanticObject(applicationProjection.projection);
-    const client = await identifiedContract(clientProjection.projection);
+    const clientMarked = withReadCache(clientProjection.projection, compilerConfig.client.pipelines);
+    const client = await identifiedContract(compilerConfig.access === undefined
+        ? clientMarked
+        : { ...clientMarked, access: compilerConfig.access });
     const agent = await identifiedContract(agentProjection.projection);
     for (const [layer, contract] of [
         ["client", client],
@@ -1007,18 +1175,100 @@ export async function compileContracts(model, config) {
             };
         }
     }
-    bindShapedFields(core, compilerConfig.definitions);
-    bindShapedFields(application, compilerConfig.definitions);
-    bindShapedFields(client, compilerConfig.definitions);
-    bindShapedFields(agent, compilerConfig.definitions);
-    bindFieldValidators(core, coreCompilation.validators);
-    bindFieldValidators(application, applicationProjection.validators);
-    bindFieldValidators(client, clientProjection.validators);
-    bindFieldValidators(agent, agentProjection.validators);
-    return {
-        ok: true,
-        contracts: { core, application, client, agent },
-    };
+    const contracts = { core, application, client, agent };
+    bindRuntimePieces(contracts, compilerConfig.definitions, {
+        core: coreCompilation.validators,
+        application: applicationProjection.validators,
+        client: clientProjection.validators,
+        agent: agentProjection.validators,
+    });
+    return { ok: true, contracts };
+}
+function lastCacheOf(levels) {
+    for (let index = (levels?.length ?? 0) - 1; index >= 0; index -= 1) {
+        const stage = levels?.[index]?.cache;
+        if (stage !== undefined) {
+            return { for: stage.for ?? "user", maxAge: stage.maxAge };
+        }
+    }
+    return undefined;
+}
+function withReadCache(projection, tree) {
+    const layer = lastCacheOf(tree.layer);
+    const resources = {};
+    for (const [name, resource] of Object.entries(projection.resources)) {
+        const pipelines = Object.hasOwn(tree.resources, name)
+            ? tree.resources[name]
+            : undefined;
+        const find = Object.hasOwn(pipelines?.families ?? {}, "find")
+            ? pipelines?.families.find
+            : undefined;
+        const fallback = lastCacheOf(find?.pipelines) ??
+            lastCacheOf(pipelines?.pipelines) ??
+            layer;
+        const advertised = (resource.operations.find ?? {});
+        const marks = {};
+        for (const variant of Object.keys(advertised)) {
+            if (!isOperationVariantAvailable(advertised[variant])) {
+                continue;
+            }
+            const own = Object.hasOwn(find?.variants ?? {}, variant)
+                ? find?.variants[variant]?.pipelines
+                : undefined;
+            const mark = lastCacheOf(own) ?? fallback;
+            if (mark !== undefined) {
+                marks[variant] = mark;
+            }
+        }
+        resources[name] =
+            Object.keys(marks).length === 0
+                ? resource
+                : { ...resource, cache: marks };
+    }
+    return { ...projection, resources };
+}
+function bindRuntimePieces(contracts, definitions, validators) {
+    for (const origin of ["core", "application", "client", "agent"]) {
+        bindShapedFields(contracts[origin], definitions);
+        bindFieldValidators(contracts[origin], validators[origin]);
+    }
+}
+export function bindPrebuiltContracts(model, config, contracts) {
+    const compilerConfig = config;
+    const fields = validatedFieldsView(model, compilerConfig.definitions);
+    bindRuntimePieces(contracts, compilerConfig.definitions, {
+        core: compileValidatorTable(fields, compilerConfig.root.pipelines),
+        application: compileValidatorTable(fields, compilerConfig.application.pipelines),
+        client: compileValidatorTable(fields, compilerConfig.client.pipelines),
+        agent: compileValidatorTable(fields, compilerConfig.agent.pipelines),
+    });
+}
+function validatedFieldsView(model, definitions) {
+    const resources = { ...model.resources };
+    for (const [resourceName, resourceDefinitions] of Object.entries(definitions)) {
+        const resource = Object.hasOwn(model.resources, resourceName)
+            ? model.resources[resourceName]
+            : undefined;
+        if (resource === undefined) {
+            continue;
+        }
+        let added;
+        for (const [fieldName, definition] of Object.entries(resourceDefinitions)) {
+            if (Object.hasOwn(resource.fields, fieldName)) {
+                continue;
+            }
+            added ??= {};
+            added[fieldName] = {
+                kind: "scalar",
+                type: definition.type,
+                list: definition.list,
+            };
+        }
+        if (added !== undefined) {
+            resources[resourceName] = { fields: { ...resource.fields, ...added } };
+        }
+    }
+    return resources;
 }
 async function identifiedContract(projection) {
     const members = canonicalizeContractMembers({

package/dist/compiler/create-requirements.projector.js

@@ -1,8 +1,6 @@
 import { advertisedDirectives, advertisedDirectivesAt, } from "../contracts/field.js";
 import { isOperationVariantAvailable, writeScopeOf, } from "../contracts/resource-operations.js";
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { isRecord } from "../runtime/record.guard.js";
 function own(record, key) {
     return Object.hasOwn(record, key) ? record[key] : undefined;
 }

package/dist/compiler/field-validator.compiler.js

@@ -1,8 +1,6 @@
 import { avzCheckOf, } from "../avz/avz-check.registry.js";
 import { FIELD_CHECK_SUBJECTS, } from "../runtime/field-check.evaluator.js";
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { isRecord } from "../runtime/record.guard.js";
 function own(record, key) {
     return Object.hasOwn(record, key) ? record[key] : undefined;
 }

package/dist/compiler/managed-elsewhere.projector.d.ts

@@ -0,0 +1,52 @@
+import type { AvAdapterModel } from "../adapters/adapter-model.js";
+import type { AvContractCompilerDiagnostic } from "./contract-compiler-diagnostic.js";
+type ProjectedField = Record<string, unknown> & {
+    kind: "scalar" | "relation";
+};
+type ProjectedResource = {
+    fields: Record<string, ProjectedField>;
+    operations: Record<string, unknown>;
+    schema?: string;
+    managedElsewhere?: true;
+};
+type ProjectedContract = {
+    resources: Record<string, ProjectedResource>;
+};
+/** The Resources the root's `resources` tree marks `managedElsewhere: true`. */
+export declare function managedElsewhereOf(rootTree: unknown): ReadonlySet<string>;
+/**
+ * Takes every write of a managed Resource away from `baseline`: its write
+ * families, its fields' `create`/`update`, and the directives of every relation
+ * into it that would write its rows.
+ */
+export declare function withholdManagedWrites(baseline: ProjectedContract, managed: ReadonlySet<string>): void;
+/**
+ * Leaves every managed Resource out of `view`, with every relation into it: the
+ * client's and the agent's parent view.
+ */
+export declare function hideManagedElsewhere(view: ProjectedContract, managed: ReadonlySet<string>): void;
+/**
+ * Leaves out of `view` (a client's or the agent's projection) each enum the
+ * managed Resources' fields use in `unhidden` (the view before they were
+ * hidden) and no field of `view` uses.
+ */
+export declare function pruneManagedEnums(view: ProjectedContract & {
+    enums: Record<string, unknown>;
+}, unhidden: ProjectedContract, managed: ReadonlySet<string>): void;
+/**
+ * The Core Contract's Resource facts: the `schema` the adapter states, and
+ * `managedElsewhere: true` on each managed Resource.
+ */
+export declare function markCoreResources(projection: ProjectedContract, model: AvAdapterModel, managed: ReadonlySet<string>): void;
+/**
+ * Why a write family of a managed Resource is unavailable, or `undefined` when
+ * the Resource is not managed or the family is not a write.
+ */
+export declare function managedWriteReason(managed: ReadonlySet<string>, resource: string, family: string): string | undefined;
+/**
+ * Adds to each create-requirement refusal from `from` on whose relation points
+ * at a managed Resource why that relation cannot be written, and the reference
+ * fields that can: exposing the relation, the refusal's own advice, is not open.
+ */
+export declare function explainManagedRefusals(diagnostics: AvContractCompilerDiagnostic[], from: number, layer: string, universe: ProjectedContract, managed: ReadonlySet<string>): void;
+export {};