@noodleseed/one 0.162.0 → 0.164.0

package/node_modules/@noodle-borg/compiler/dist/compile.js

@@ -9,6 +9,7 @@ import { emitCatalogArtifactSurfaces, isContextProvider, } from './artifact/cata
 import { MCP_APP_MIME_TYPE, } from './artifact/types.js';
 import { rewriteHostedAssets, rewriteLocalAssets, } from './assets.js';
 import { brandingWarnings, normalizeRuntimeBranding } from './branding.js';
+import { compileVariableDeclarations } from './business-variables.js';
 import { validateInteractiveFlow } from './confirmation-flow.js';
 import { parseAmbientContext } from './context-compile.js';
 import { findExternalRef, parseFulfilment } from './fulfilment-structural.js';
@@ -144,7 +145,11 @@ export function compileManifest(raw, options = {}) {
     // 2. Structural passes (catalog-independent): duplicate names, `$use` resolution, external refs,
     // fulfilment parsing. `$use` is resolved first so external-ref detection also scans bundled defs.
     const errors = widgetHtmlSizeErrors(manifest, runtimeBranding);
-    const managedCollections = compileManagedCollections(manifest.manifestVersion === '2' ? (manifest.server.collections ?? []) : [], manifest.tools.map((tool) => tool.name), errors);
+    const variables = compileVariableDeclarations(manifest.manifestVersion === '2' ? (manifest.server.variables ?? []) : [], manifest.tools.map((tool) => tool.name), errors);
+    const managedCollections = compileManagedCollections(manifest.manifestVersion === '2' ? (manifest.server.collections ?? []) : [], manifest.tools.map((tool) => tool.name), errors, {
+        ...(options.catalog === undefined ? {} : { catalog: options.catalog }),
+        declared: manifest.connectors ?? {},
+    });
     const requirements = parseCapabilityRequirements(manifest.requires, errors);
     const seen = new Set();
     const schemasMap = manifest.schemas ?? {};
@@ -437,6 +442,7 @@ export function compileManifest(raw, options = {}) {
         customerEndpoints,
         ...(knowledge.length > 0 ? { knowledge } : {}),
         ...(managedCollections.length > 0 ? { managedCollections } : {}),
+        ...(variables.length > 0 ? { variables } : {}),
     });
     const warnings = [
         ...brandingWarnings(manifest.server.branding),

package/node_modules/@noodle-borg/compiler/dist/errors.d.ts

@@ -1,7 +1,7 @@
 import type { AppPackageArtifactV1 } from '@noodle-borg/app-package';
 import type { RuntimeArtifact } from './artifact/types.js';
 import type { PackagedAsset } from './assets.js';
-export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
+export type CompileErrorCode = 'invalid_context_provider' | 'yaml_parse_error' | 'invalid_shape' | 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'unsupported_manifest_version' | 'reserved_for_future_version' | 'invalid_operation_ref' | 'external_ref' | 'invalid_schema_ref' | 'unknown_schema_ref' | 'schema_ref_conflict' | 'invalid_expression' | 'expr_unknown_root' | 'expr_root_unavailable' | 'expr_operator_not_allowed' | 'expr_if_not_boolean' | 'unknown_step_ref' | 'forward_step_ref' | 'self_step_ref' | 'duplicate_step_id' | 'invalid_fulfilment' | 'invalid_elicitation_schema' | 'invalid_elicitation_flow' | 'invalid_confirmation_flow' | 'arg_type_mismatch' | 'ambient_context_action' | 'duplicate_resource' | 'duplicate_prompt' | 'duplicate_resource_uri' | 'unsupported_uri_template' | 'duplicate_widget' | 'unknown_widget_tool' | 'unknown_widget_action_tool' | 'duplicate_widget_tool' | 'invalid_widget_binding' | 'invalid_widget_state_handle' | 'widget_html_too_large' | 'widget_html_total_too_large' | 'invalid_asset' | 'invalid_capability_requirement' | 'state_secret_field' | 'invalid_knowledge' | 'knowledge_unhashed' | 'invalid_managed_collection' | 'invalid_variable_declaration' | 'invalid_managed_collection_source' | 'unknown_connector_alias' | 'connector_not_in_catalog' | 'unknown_operation' | 'connector_binding_required' | 'unsupported_credential_profile' | 'credential_scope_mismatch' | 'credential_audience_mismatch' | 'customer_endpoint_auth_required' | 'customer_endpoint_mapping_required' | 'customer_endpoint_unknown_mapping' | 'customer_endpoint_bridge_unsupported' | 'assistant_capability_unknown' | 'assistant_public_user_reference' | 'assistant_public_effect_unconfirmed' | 'customer_endpoint_action_unsupported' | 'customer_endpoint_surface_unsupported' | 'customer_endpoint_credential_source_unsupported' | 'customer_endpoint_policy_conflict' | 'customer_endpoint_routing_inconsistent' | 'unused_connector_alias' | 'arg_mismatch' | 'agent_guide_invalid' | 'agent_guide_duplicate_workflow' | 'agent_guide_duplicate_example' | 'agent_guide_example_workflow_missing' | 'agent_guide_capability_missing' | 'agent_guide_capability_kind' | 'app_package_sensitive_content';
 export interface CompileError {
     readonly code: CompileErrorCode;
     /** Dotted path to the offending location (e.g. `tools.1.name`); empty string for the document root. */

package/node_modules/@noodle-borg/compiler/dist/index.d.ts

@@ -5,6 +5,7 @@ export { compileAppPackage } from './app-package/compile.js';
 export { isSafeReadTool, requiresToolConfirmation } from './artifact/consent.js';
 export { ARTIFACT_SCHEMA_VERSION, type ArtifactConnectionSource, type ArtifactConnectorBinding, type ArtifactCustomerAuthRouting, type ArtifactFulfilment, type ArtifactManagedCollection, type ArtifactMeta, type ArtifactPackagedAsset, type ArtifactPrompt, type ArtifactPromptArgument, type ArtifactResource, type ArtifactServer, type ArtifactServerContext, type ArtifactState, type ArtifactStateHandle, type ArtifactStateHandleKind, type ArtifactStateHandleScope, type ArtifactStep, type ArtifactTool, type ArtifactToolAuthorization, type ExprMap, type JsonSchema, MCP_APP_MIME_TYPE, type OperationRef, type ResolvedCredentialBinding, type ResolvedOperationRef, type RuntimeArtifact, type UnresolvedOperationRef, type WidgetUiMeta, } from './artifact/types.js';
 export { assetReference, type HostedAssetOptions, type HostedPackagedAsset, isPackagedAssetReference, type LocalAssetOptions, localAssetRoutePrefix, type PackagedAsset, type PackagedAssetReference, type PreparedPackagedAsset, prepareLocalAssets, } from './assets.js';
+export { type ArtifactVariableDeclaration, compileVariableDeclarations, MAX_VARIABLE_DECLARATIONS, MAX_VARIABLE_SCHEMA_BYTES, MAX_VARIABLE_SCHEMA_DEPTH, MAX_VARIABLE_VALUE_BYTES, type VariableDeclarationManifest, validateVariableDeclaration, variableDeclarationManifestSchema, } from './business-variables.js';
 export { InMemoryCatalog } from './catalog/in-memory.js';
 export { isLegacyFieldMap, normalizeOperationIoSchema } from './catalog/io-schema.js';
 export { computeSignatureHash } from './catalog/signature.js';
@@ -13,6 +14,7 @@ export { type CompileOptions, compile, compileManifest, type ValidateResult, val
 export { type CustomerEndpointPolicy, type CustomerEndpointRef, isCustomerEndpointRef, isValidCustomerEndpointName, normalizeCustomerEndpointPolicy, resolveCustomerEndpointBaseUrl, } from './customer-endpoint.js';
 export type { CompileError, CompileErrorCode, CompileResult } from './errors.js';
 export { computeConnectionConfigRevision } from './fulfilment-emit.js';
+export { type ManagedCollectionControls, projectManagedCollectionControls, validateManagedCollectionControls, } from './managed-collection-controls.js';
 export { MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH, MAX_MANAGED_COLLECTION_NAME_LENGTH, MAX_MANAGED_COLLECTION_RECORD_FIELDS, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH, MAX_MANAGED_COLLECTION_SCHEMA_VERSION, MAX_MANAGED_COLLECTION_TITLE_LENGTH, MAX_MANAGED_COLLECTIONS, type ManagedCollectionManifest, } from './managed-collections.js';
 export { type CspFault, type CspList, cspFaultsInManifest, cspOriginFaults, isHonorableCspOrigin, } from './manifest/csp-origins.js';
 export { type ArrayNode, type CoalesceNode, type CondNode, type ExprNode, type ObjectEntry, type ObjectNode, type PathNode, type PathSegment, parseCondition, parseValue, } from './manifest/expression.js';
@@ -21,6 +23,7 @@ export { type Manifest, manifestSchema } from './manifest/schema.js';
 export { type ResolveSchemaResult, resolveSchemaUses, type SchemasMap, } from './manifest/schema-refs.js';
 export { anonymousBehavior } from './manifest/website-projection.js';
 export { type SniffedImage, sniffImageBytes } from './mime-sniffing.js';
+export { BUILTIN_RECORD_CATALOG_CONNECTOR, RECORD_CONNECTOR_ID, RECORD_CONNECTOR_VERSION, RECORD_OPERATION_SIGNATURES, } from './native-record-operations.js';
 export { manifestJsonSchema } from './schema-export.js';
 export { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES, MAX_TOTAL_WIDGET_HTML_BYTES, RECOMMENDED_COMPILED_WIDGET_HTML_BYTES, } from './widget-limits.js';
 //# sourceMappingURL=index.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/index.js

@@ -4,12 +4,14 @@ export { compileAppPackage } from './app-package/compile.js';
 export { isSafeReadTool, requiresToolConfirmation } from './artifact/consent.js';
 export { ARTIFACT_SCHEMA_VERSION, MCP_APP_MIME_TYPE, } from './artifact/types.js';
 export { assetReference, isPackagedAssetReference, localAssetRoutePrefix, prepareLocalAssets, } from './assets.js';
+export { compileVariableDeclarations, MAX_VARIABLE_DECLARATIONS, MAX_VARIABLE_SCHEMA_BYTES, MAX_VARIABLE_SCHEMA_DEPTH, MAX_VARIABLE_VALUE_BYTES, validateVariableDeclaration, variableDeclarationManifestSchema, } from './business-variables.js';
 export { InMemoryCatalog } from './catalog/in-memory.js';
 export { isLegacyFieldMap, normalizeOperationIoSchema } from './catalog/io-schema.js';
 export { computeSignatureHash } from './catalog/signature.js';
 export { compile, compileManifest, validateManifest, } from './compile.js';
 export { isCustomerEndpointRef, isValidCustomerEndpointName, normalizeCustomerEndpointPolicy, resolveCustomerEndpointBaseUrl, } from './customer-endpoint.js';
 export { computeConnectionConfigRevision } from './fulfilment-emit.js';
+export { projectManagedCollectionControls, validateManagedCollectionControls, } from './managed-collection-controls.js';
 export { MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH, MAX_MANAGED_COLLECTION_NAME_LENGTH, MAX_MANAGED_COLLECTION_RECORD_FIELDS, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES, MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH, MAX_MANAGED_COLLECTION_SCHEMA_VERSION, MAX_MANAGED_COLLECTION_TITLE_LENGTH, MAX_MANAGED_COLLECTIONS, } from './managed-collections.js';
 export { cspFaultsInManifest, cspOriginFaults, isHonorableCspOrigin, } from './manifest/csp-origins.js';
 export { parseCondition, parseValue, } from './manifest/expression.js';
@@ -18,6 +20,7 @@ export { manifestSchema } from './manifest/schema.js';
 export { resolveSchemaUses, } from './manifest/schema-refs.js';
 export { anonymousBehavior } from './manifest/website-projection.js';
 export { sniffImageBytes } from './mime-sniffing.js';
+export { BUILTIN_RECORD_CATALOG_CONNECTOR, RECORD_CONNECTOR_ID, RECORD_CONNECTOR_VERSION, RECORD_OPERATION_SIGNATURES, } from './native-record-operations.js';
 export { manifestJsonSchema } from './schema-export.js';
 export { MAX_COMPILED_WIDGET_HTML_BYTES, MAX_RAW_WIDGET_HTML_BYTES, MAX_TOTAL_WIDGET_HTML_BYTES, RECOMMENDED_COMPILED_WIDGET_HTML_BYTES, } from './widget-limits.js';
 //# sourceMappingURL=index.js.map

package/node_modules/@noodle-borg/compiler/dist/managed-collection-controls.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { CompileError } from './errors.js';
+export declare const managedCollectionControlFields: {
+    management: z.ZodOptional<z.ZodObject<{
+        assignment: z.ZodOptional<z.ZodLiteral<true>>;
+        notes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    publicFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    summaryFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sortFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+};
+declare const controlsSchema: z.ZodObject<{
+    management: z.ZodOptional<z.ZodObject<{
+        assignment: z.ZodOptional<z.ZodLiteral<true>>;
+        notes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    publicFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    summaryFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sortFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export interface ManagedCollectionControls {
+    readonly management?: {
+        readonly assignment?: true | undefined;
+        readonly notes?: true | undefined;
+    } | undefined;
+    readonly fields?: Readonly<Record<string, {
+        readonly label?: string | undefined;
+        readonly help?: string | undefined;
+    }>> | undefined;
+    readonly publicFields?: readonly string[] | undefined;
+    readonly editableFields?: readonly string[] | undefined;
+    readonly summaryFields?: readonly string[] | undefined;
+    readonly filterFields?: readonly string[] | undefined;
+    readonly sortFields?: readonly string[] | undefined;
+}
+/** Validate presentation/exposure against actual record fields, independently of application names. */
+export declare function validateManagedCollectionControls(controls: ManagedCollectionControls, schema: Readonly<Record<string, unknown>>, external: boolean, path: string, errors: CompileError[]): void;
+export declare function projectManagedCollectionControls(value: ManagedCollectionControls): z.infer<typeof controlsSchema>;
+export {};
+//# sourceMappingURL=managed-collection-controls.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/managed-collection-controls.js

@@ -0,0 +1,92 @@
+import { validateJsonSchema } from '@noodle-borg/app-package';
+import { z } from 'zod';
+const fieldName = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^(?!(?:__proto__|constructor|prototype)$)[A-Za-z_][A-Za-z0-9_]*$/);
+const fieldList = z.array(fieldName).max(128);
+const plainText = (max) => z
+    .string()
+    .trim()
+    .min(1)
+    .max(max)
+    .regex(/^[^<>\p{Cc}]+$/u);
+export const managedCollectionControlFields = {
+    management: z
+        .object({ assignment: z.literal(true).optional(), notes: z.literal(true).optional() })
+        .strict()
+        .optional(),
+    fields: z
+        .record(fieldName, z.object({ label: plainText(120).optional(), help: plainText(1000).optional() }).strict())
+        .optional(),
+    publicFields: fieldList.optional(),
+    editableFields: fieldList.optional(),
+    summaryFields: fieldList.optional(),
+    filterFields: fieldList.optional(),
+    sortFields: fieldList.optional(),
+};
+const controlsSchema = z.object(managedCollectionControlFields).strict();
+/** Validate presentation/exposure against actual record fields, independently of application names. */
+export function validateManagedCollectionControls(controls, schema, external, path, errors) {
+    const fail = (suffix, message) => errors.push({ code: 'invalid_managed_collection', path: `${path}.${suffix}`, message });
+    if (!controlsSchema.safeParse(controls).success) {
+        fail('fields', 'invalid collection management or field metadata');
+        return;
+    }
+    const properties = isObject(schema.properties) ? schema.properties : {};
+    for (const key of [
+        'publicFields',
+        'editableFields',
+        'summaryFields',
+        'filterFields',
+        'sortFields',
+    ]) {
+        const names = controls[key] ?? [];
+        if (new Set(names).size !== names.length)
+            fail(key, 'duplicate field reference');
+        for (const name of names) {
+            if (!Object.hasOwn(properties, name))
+                fail(key, 'field is not declared in the record schema');
+            if ((key === 'filterFields' || key === 'sortFields') &&
+                (!isObject(properties[name]) ||
+                    !['string', 'number', 'integer', 'boolean'].includes(String(properties[name].type))))
+                fail(key, 'filter and sort fields must be scalar values');
+        }
+    }
+    for (const name of Object.keys(controls.fields ?? {}))
+        if (!Object.hasOwn(properties, name))
+            fail('fields', 'metadata must name a declared field');
+    if (external &&
+        (controls.management !== undefined ||
+            (controls.publicFields?.length ?? 0) > 0 ||
+            (controls.editableFields?.length ?? 0) > 0))
+        fail('management', 'external reference collections cannot enable record writes, assignment or notes');
+    if ((controls.publicFields?.length ?? 0) > 0 && Array.isArray(schema.required)) {
+        for (const name of schema.required) {
+            if (typeof name !== 'string' || controls.publicFields?.includes(name))
+                continue;
+            const property = properties[name];
+            if (!isObject(property) ||
+                !Object.hasOwn(property, 'default') ||
+                validateJsonSchema(property, property.default).length > 0)
+                fail('publicFields', 'required non-public fields need valid creation defaults');
+        }
+    }
+    for (const property of Object.values(properties)) {
+        if (isObject(property) &&
+            Object.hasOwn(property, 'default') &&
+            validateJsonSchema(property, property.default).length > 0)
+            fail('recordSchema', 'creation default does not match its field schema');
+    }
+}
+export function projectManagedCollectionControls(value) {
+    return controlsSchema.parse(Object.fromEntries(Object.keys(managedCollectionControlFields).flatMap((key) => {
+        const entry = value[key];
+        return entry === undefined ? [] : [[key, structuredClone(entry)]];
+    })));
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+//# sourceMappingURL=managed-collection-controls.js.map

package/node_modules/@noodle-borg/compiler/dist/managed-collections.d.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import type { ArtifactManagedCollection } from './artifact/types.js';
+import type { ConnectorCatalog } from './catalog/types.js';
 import type { CompileError } from './errors.js';
+import { type DeclaredConnectorRef } from './fulfilment-emit.js';
 export declare const MAX_MANAGED_COLLECTIONS = 16;
 export declare const MAX_MANAGED_COLLECTION_NAME_LENGTH = 64;
 export declare const MAX_MANAGED_COLLECTION_TITLE_LENGTH = 120;
@@ -10,16 +12,39 @@ export declare const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES: number;
 export declare const MAX_MANAGED_COLLECTION_RECORD_SCHEMA_DEPTH = 12;
 export declare const MAX_MANAGED_COLLECTION_RECORD_FIELDS = 128;
 export declare const managedCollectionManifestSchema: z.ZodObject<{
+    management: z.ZodOptional<z.ZodObject<{
+        assignment: z.ZodOptional<z.ZodLiteral<true>>;
+        notes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodOptional<z.ZodString>;
+        help: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    publicFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    editableFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    summaryFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    filterFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sortFields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     name: z.ZodString;
     title: z.ZodString;
     description: z.ZodString;
     schemaVersion: z.ZodNumber;
     recordSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    behavior: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"request">;
+    }, z.core.$strict>>;
+    source: z.ZodOptional<z.ZodObject<{
+        connector: z.ZodString;
+        scan: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ManagedCollectionManifest = z.infer<typeof managedCollectionManifestSchema>;
 /**
  * Validate and lower reusable collection intent. Operator lifecycle, grants, residency, and
  * retention deliberately do not enter this compiled definition.
  */
-export declare function compileManagedCollections(collections: readonly ManagedCollectionManifest[], toolNames: readonly string[], errors: CompileError[]): readonly ArtifactManagedCollection[];
+export declare function compileManagedCollections(collections: readonly ManagedCollectionManifest[], toolNames: readonly string[], errors: CompileError[], options?: {
+    readonly catalog?: ConnectorCatalog;
+    readonly declared?: Readonly<Record<string, DeclaredConnectorRef>>;
+}): readonly ArtifactManagedCollection[];
 //# sourceMappingURL=managed-collections.d.ts.map

package/node_modules/@noodle-borg/compiler/dist/managed-collections.js

@@ -1,5 +1,8 @@
 import { canonicalJson, sha256Canonical } from '@noodle-borg/app-package';
 import { z } from 'zod';
+import { computeSignatureHash } from './catalog/signature.js';
+import { computeConnectionConfigRevision } from './fulfilment-emit.js';
+import { managedCollectionControlFields, projectManagedCollectionControls, validateManagedCollectionControls, } from './managed-collection-controls.js';
 export const MAX_MANAGED_COLLECTIONS = 16;
 export const MAX_MANAGED_COLLECTION_NAME_LENGTH = 64;
 export const MAX_MANAGED_COLLECTION_TITLE_LENGTH = 120;
@@ -14,6 +17,12 @@ const collectionNameSchema = z
     .max(MAX_MANAGED_COLLECTION_NAME_LENGTH)
     .regex(/^[a-z][a-z0-9_]*$/, 'must start with a letter and use lowercase letters, numbers, and underscores');
 const jsonSchemaSchema = z.record(z.string(), z.unknown());
+const sourceSchema = z
+    .object({
+    connector: collectionNameSchema,
+    scan: collectionNameSchema,
+})
+    .strict();
 export const managedCollectionManifestSchema = z
     .object({
     name: collectionNameSchema,
@@ -21,6 +30,12 @@ export const managedCollectionManifestSchema = z
     description: z.string().trim().min(1).max(MAX_MANAGED_COLLECTION_DESCRIPTION_LENGTH),
     schemaVersion: z.number().int().positive().max(MAX_MANAGED_COLLECTION_SCHEMA_VERSION),
     recordSchema: jsonSchemaSchema,
+    behavior: z
+        .object({ kind: z.literal('request') })
+        .strict()
+        .optional(),
+    source: sourceSchema.optional(),
+    ...managedCollectionControlFields,
 })
     .strict();
 const PROHIBITED_FIELD_NAME = /(?:card|cvv|cvc|password|passcode|token|secret|passport|governmentid|nationalid|socialsecurity|health|biometric)/i;
@@ -45,7 +60,7 @@ const SUBSCHEMA_LIST_KEYS = ['prefixItems', 'allOf', 'anyOf', 'oneOf'];
  * Validate and lower reusable collection intent. Operator lifecycle, grants, residency, and
  * retention deliberately do not enter this compiled definition.
  */
-export function compileManagedCollections(collections, toolNames, errors) {
+export function compileManagedCollections(collections, toolNames, errors, options = {}) {
     const compiled = [];
     const seen = new Set();
     collections.forEach((collection, index) => {
@@ -70,8 +85,12 @@ export function compileManagedCollections(collections, toolNames, errors) {
         }
         const schemaErrorsBefore = errors.length;
         validateRecordSchema(collection.recordSchema, `${path}.recordSchema`, errors);
+        validateManagedCollectionControls(projectManagedCollectionControls(collection), collection.recordSchema, collection.source !== undefined, path, errors);
         if (errors.length !== schemaErrorsBefore)
             return;
+        const source = compileCollectionSource(collection, path, errors, options);
+        if (collection.source !== undefined && source === undefined)
+            return;
         compiled.push({
             name: collection.name,
             title: collection.title,
@@ -79,10 +98,180 @@ export function compileManagedCollections(collections, toolNames, errors) {
             schemaVersion: collection.schemaVersion,
             schemaDigest: sha256Canonical(collection.recordSchema),
             recordSchema: collection.recordSchema,
+            ...projectManagedCollectionControls(collection),
+            ...(collection.behavior === undefined ? {} : { behavior: collection.behavior }),
+            source: source ?? { authority: 'native' },
         });
     });
     return compiled;
 }
+function compileCollectionSource(collection, path, errors, options) {
+    if (collection.source === undefined)
+        return { authority: 'native' };
+    const declared = options.declared?.[collection.source.connector];
+    if (declared === undefined) {
+        sourceError(errors, `${path}.source.connector`, `connector alias "${collection.source.connector}" is not declared`);
+        return undefined;
+    }
+    if (declared.binding === undefined) {
+        sourceError(errors, `${path}.source.connector`, 'external collection sources require an operator-bound connector');
+        return undefined;
+    }
+    const connector = options.catalog?.get(declared.id, declared.version);
+    if (options.catalog !== undefined && connector === undefined) {
+        sourceError(errors, `${path}.source.connector`, `connector "${declared.id}" version "${declared.version}" is not in the catalog`);
+        return undefined;
+    }
+    const scan = resolveSourceOperation({
+        alias: collection.source.connector,
+        name: collection.source.scan,
+        connector,
+        declared,
+        recordSchema: collection.recordSchema,
+        path: `${path}.source.scan`,
+        errors,
+    });
+    if (scan === undefined)
+        return undefined;
+    return {
+        authority: 'external',
+        connectorAlias: collection.source.connector,
+        connectorId: declared.id,
+        connectorVersion: declared.version,
+        scan,
+    };
+}
+function resolveSourceOperation(input) {
+    if (input.connector === undefined) {
+        return { resolved: false, connector: input.alias, operation: input.name };
+    }
+    const operation = input.connector.operations[input.name];
+    if (operation === undefined) {
+        sourceError(input.errors, input.path, `operation "${input.name}" does not exist on connector "${input.connector.id}"`);
+        return undefined;
+    }
+    if (operation.type !== 'read') {
+        sourceError(input.errors, input.path, `source operation "${input.name}" must be classified as read`);
+        return undefined;
+    }
+    const contractError = validateScanSignature(operation, input.recordSchema);
+    if (contractError !== undefined) {
+        sourceError(input.errors, input.path, contractError);
+        return undefined;
+    }
+    const binding = input.declared.binding;
+    const credentialPresentation = binding === undefined ? undefined : input.connector.credentialProfiles?.[binding.profile];
+    if (binding === undefined || credentialPresentation === undefined) {
+        sourceError(input.errors, input.path, `source operation "${input.name}" requires a valid bound credential profile`);
+        return undefined;
+    }
+    const credentialRequirement = input.connector.operationCredentials?.[input.name];
+    if (credentialRequirement !== undefined &&
+        !credentialRequirement.profiles.includes(binding.profile)) {
+        sourceError(input.errors, input.path, `source operation "${input.name}" does not permit credential profile "${binding.profile}"`);
+        return undefined;
+    }
+    return {
+        resolved: true,
+        alias: input.alias,
+        connectorId: input.declared.id,
+        connectorVersion: input.declared.version,
+        operation: input.name,
+        signatureHash: computeSignatureHash(input.name, operation),
+        credentialBinding: {
+            bindingId: input.alias,
+            connectionId: binding.connection.id,
+            connectionConfigRevision: computeConnectionConfigRevision(binding.connection),
+            profile: binding.profile,
+            presentation: credentialPresentation,
+            requiredScopes: [...(credentialRequirement?.scopes ?? [])],
+            ...(credentialRequirement?.audience === undefined
+                ? {}
+                : { requiredAudience: credentialRequirement.audience }),
+        },
+    };
+}
+function validateScanSignature(operation, recordSchema) {
+    const input = operation.input;
+    if (!isClosedObjectWithKeys(input, ['mode', 'cursor', 'checkpoint', 'limit'])) {
+        return 'scan input must be a closed object containing only mode, cursor, checkpoint and limit';
+    }
+    const inputProperties = input.properties;
+    if (!hasTypes(inputProperties, {
+        mode: 'string',
+        cursor: 'string',
+        checkpoint: 'string',
+        limit: 'integer',
+    })) {
+        return 'scan input fields do not match the normalized source contract';
+    }
+    if (!sameStrings(input.required, ['mode', 'limit']))
+        return 'scan input must require mode and limit only';
+    const modeEnum = inputProperties.mode?.enum;
+    if (!sameStrings(modeEnum, ['snapshot', 'changes']))
+        return 'scan mode must allow snapshot and changes';
+    const output = operation.output;
+    if (!isClosedObjectWithKeys(output, [
+        'records',
+        'deletedIds',
+        'nextCursor',
+        'checkpoint',
+        'complete',
+        'resetRequired',
+    ])) {
+        return 'scan output must match the normalized source page envelope';
+    }
+    if (!sameStrings(output.required, ['records', 'deletedIds', 'complete'])) {
+        return 'scan output must require records, deletedIds and complete only';
+    }
+    const properties = output.properties;
+    if (!hasTypes(properties, {
+        records: 'array',
+        deletedIds: 'array',
+        nextCursor: 'string',
+        checkpoint: 'string',
+        complete: 'boolean',
+        resetRequired: 'boolean',
+    })) {
+        return 'scan output fields do not match the normalized source page contract';
+    }
+    const item = properties.records?.items;
+    if (!isRecord(item) || !isClosedObjectWithKeys(item, ['id', 'version', 'record'])) {
+        return 'scan records must contain closed id, optional version and record objects';
+    }
+    if (!sameStrings(item.required, ['id', 'record']))
+        return 'scan records must require id and record only';
+    const itemProperties = item.properties;
+    if (itemProperties.id?.type !== 'string' || itemProperties.version?.type !== 'string') {
+        return 'scan record id and version must be strings';
+    }
+    if (sha256Canonical(itemProperties.record) !== sha256Canonical(recordSchema)) {
+        return 'scan record schema must exactly match the managed collection record schema';
+    }
+    const deletedItems = properties.deletedIds?.items;
+    if (!isRecord(deletedItems) || deletedItems.type !== 'string')
+        return 'deletedIds must be an array of strings';
+    return undefined;
+}
+function isClosedObjectWithKeys(value, keys) {
+    if (!isRecord(value) ||
+        value.type !== 'object' ||
+        value.additionalProperties !== false ||
+        !isRecord(value.properties))
+        return false;
+    return sameStrings(Object.keys(value.properties), keys);
+}
+function hasTypes(properties, expected) {
+    return Object.entries(expected).every(([key, type]) => properties[key]?.type === type);
+}
+function sameStrings(value, expected) {
+    return (Array.isArray(value) &&
+        value.every((entry) => typeof entry === 'string') &&
+        [...value].sort().join('\u0000') === [...expected].sort().join('\u0000'));
+}
+function sourceError(errors, path, message) {
+    errors.push({ code: 'invalid_managed_collection_source', path, message });
+}
 function validateRecordSchema(schema, path, errors) {
     const bytes = new TextEncoder().encode(canonicalJson(schema)).byteLength;
     if (bytes > MAX_MANAGED_COLLECTION_RECORD_SCHEMA_BYTES) {