@jskit-ai/agent-docs 0.1.256 → 0.1.258

package/reference/autogen/packages/crud-core.md

@@ -16,36 +16,22 @@ Use this on demand; do not load the full index at startup.
 
 ### `src/server/createCrudServiceFromResource.js`
 Exports
-- `createCrudServiceFromResource(resource = {}, { context = "crudService" } = {})`
+- `createCrudServiceFromResource(resource, { context = "crudService" } = {})`
 
 ### `src/server/createHooksToCollectChildren.js`
 Exports
 - `createHooksToCollectChildren(options = {})`
 Local functions
 - `normalizeOwnerKey(value)`
-- `toDefaultChildCallOptions(callOptions = {})`
+- `readParentId(record)`
+- `toDefaultChildCallOptions({ callOptions = {} } = {})`
 - `resolveListChildrenHandler(options = {}, { context = "createHooksToCollectChildren" } = {})`
 - `resolveGetChildOwnerId(options = {}, { context = "createHooksToCollectChildren" } = {})`
-- `resolveLookupContainerKey(record = {}, hookContext = {}, options = {})`
-
-### `src/server/crudModuleConfig.js`
-Exports
-- `CRUD_REQUESTED_OWNERSHIP_FILTER_AUTO`
-- `normalizeCrudRequestedOwnershipFilter(value, { fallback = CRUD_REQUESTED_OWNERSHIP_FILTER_AUTO } = {})`
-- `isWorkspaceRouteVisibility`
-- `requireCrudNamespace`
-- `resolveCrudRelativePath(namespace = "")`
-- `normalizeCrudRelativePath(relativePath = "", { context = "resolveCrudSurfacePolicy" } = {})`
-- `resolveCrudSurfacePolicy(sourceConfig = {}, { surfaceDefinitions = {}, defaultSurfaceId = "", context = "resolveCrudSurfacePolicy" } = {})`
-- `resolveCrudSurfacePolicyFromAppConfig(sourceConfig = {}, appConfig = {}, options = {})`
-Local functions
-- `asRecord(value)`
-- `normalizeSurfaceDefinitions(sourceDefinitions = {})`
-- `resolveOwnershipFilterFromSurfaceDefinition(definition = {})`
+- `resolveChildrenContainerKey(hookContext = {}, options = {})`
 
 ### `src/server/defineCrudJsonApiFeature.js`
 Exports
-- `defineCrudJsonApiFeature({ resource, id = "", capability = "", surface, ownershipFilter = "", relativePath = "", internal = false, routes = true, listFilterQueryValidator = null, searchSchema = null, permissions = null, scope = {}, requires = {}, decorateRepository = null, decorateService = null, operationLifecycle = {}, operationInputs = {}, actions = {}, operations = undefined, realtimeAudience = "event_scope" } = {})`
+- `defineCrudJsonApiFeature({ resource, id = "", capability = "", surface, ownershipFilter = "", relativePath = "", internal = false, routes = true, listFilterQueryValidator = null, searchSchema = null, permissions = null, scope = {}, requires = {}, decorateRepository = null, decorateService = null, operationLifecycle = {}, operationInputs = {}, actions = {}, operations = undefined, realtimeAudience = "event_scope" })`
 Local functions
 - `normalizeAccess(resource = {})`
 - `normalizeScope(scope = {})`
@@ -53,7 +39,7 @@ Local functions
 - `normalizeFeatureRequirements(requires = {})`
 - `operationsFromResource(resource)`
 - `normalizeOperations(operations, resource)`
-- `resolveActionPermission(actionName, { access, workspaceScoped, permissions } = {})`
+- `resolveActionPermission(actionName, { access, workspaceScoped, permissions })`
 - `projectEnabledServiceOperations(service, operations)`
 
 ### `src/server/fieldAccess.js`
@@ -64,96 +50,117 @@ Local functions
 - `normalizeFieldSet(value, { context = "crudFieldAccess", label = "field list" } = {})`
 - `resolveFieldSet(resolver, input = {}, { context = "crudFieldAccess", label = "field list" } = {})`
 - `resolveWriteMode(fieldAccess = {}, { context = "crudFieldAccess" } = {})`
-- `buildOutputFieldRules(resource = {})`
-- `resolveRoleFromFieldAccessInput(input = {})`
-- `resolveActionFromFieldAccessInput(input = {})`
+- `buildOutputFieldRules(resource)`
+- `resolveRoleFromFieldAccessInput(input)`
+- `resolveActionFromFieldAccessInput(input)`
 - `resolveOperationPolicyValue(operationPolicy, input = {}, action = "*")`
 - `resolveRoleMatrixPolicy(matrix = {}, operation = "readable", input = {})`
-- `applyReadableFieldPolicyToRecord(record, allowedFields, outputRules = null, { context = "crudFieldAccess" } = {})`
+- `applyReadableFieldPolicyToRecord(record, allowedFields, outputRules, { context = "crudFieldAccess" } = {})`
 
 ### `src/server/jsonApiModule/actions.js`
 Exports
 - `assertCrudOperationName(operation = "")`
-- `createCrudJsonApiActions({ namespace, resource, repository = null, service, surface, permissionForOperation, permissionForAction = permissionForOperation, operations = CRUD_OPERATION_NAMES, scopeInputValidator = null, scopeInputKeys = [], listFilterQueryValidator = null, operationLifecycle = {}, operationInputs = {}, actions: additionalActionDefinitions = {}, dependencies = {}, realtimeAudience = "event_scope" } = {})`
-- `normalizeCrudOperationLifecycle(value = {})`
+- `createCrudJsonApiActions({ namespace, resource, repository, service, surface, permissionForOperation, operations, scopeInputValidator, scopeInputKeys, listFilterQueryValidator, operationLifecycle, operationInputs, actions, dependencies, realtimeAudience })`
+- `normalizeCrudOperationLifecycle(value)`
+Local functions
+- `buildActionInput(resource, operation, scopeInputValidator, listFilterQueryValidator, operationInputs)`
+- `omitInputKeys(input, keys)`
+- `buildLifecycleContext(value)`
+- `normalizeAdditionalActions(definitions, { namespace, surface, permissionForAction, scopeInputValidator })`
+
+### `src/server/jsonApiModule/assistantExtension.js`
+Exports
+- `createCrudAssistantExtension(resource, namespace, operation)`
 Local functions
-- `isRecord(value)`
-- `normalizeOptionalCursor(value)`
 - `resolveAssistantResultValue(result)`
-- `createProjectionRecordSchema(recordSchema, { lookupContainerKey = "", relationshipEntries = [] } = {})`
-- `createProjectionOutputDefinition(output, operation, relationshipEntries, lookupContainerKey)`
-- `createCrudAssistantTransport(resource, operation, relationshipEntries, lookupContainerKey)`
+- `buildProjectionRecordSchema(recordSchema, { lookupContainerKey = "", relationshipEntries = [] } = {})`
+- `buildProjectionOutputDefinition(output, operation, relationshipEntries, lookupContainerKey)`
+- `buildCrudAssistantTransport(resource, operation, relationshipEntries, lookupContainerKey)`
 - `projectCrudAssistantRecordFields(record, selectedFields = null, { preserveKeys = [] } = {})`
 - `projectCrudAssistantLookupValue(value, selectedFields = null)`
 - `projectCrudAssistantReadRecord(record, { lookupContainerKey = "", primaryFields = null, relatedFieldsByLookupKey = new Map() } = {})`
-- `createCrudAssistantResultProjection(input = {}, resource = {}, relationshipEntries = [])`
+- `buildCrudAssistantResultProjection(input, resource, relationshipEntries = [])`
 - `projectCrudAssistantReadResult(result, projection = null, { lookupContainerKey = "" } = {})`
 - `transformCrudAssistantResult(operation, result, { input = {}, resource, relationshipEntries = [], lookupContainerKey = "" } = {})`
-- `createCrudAssistantReadDescription({ fieldsetContract, lookupContainerKey = "", namespace = "", operation = "list" } = {})`
-- `createCrudAssistantExtension(resource, namespace, operation)`
-- `createActionInput(resource, operation, scopeInputValidator = null, listFilterQueryValidator = null, operationInputs = {})`
-- `omitInputKeys(input = {}, keys = [])`
-- `createLifecycleContext(value = {})`
-- `normalizeAdditionalActions(value = {}, { namespace, surface, permissionForAction, scopeInputValidator = null } = {})`
+- `buildCrudAssistantReadDescription({ fieldsetContract, lookupContainerKey = "", namespace = "", operation = "list" } = {})`
+
+### `src/server/jsonApiModule/customActionId.js`
+Exports
+- `buildCrudCustomActionId(namespace, name, definition)`
 
 ### `src/server/jsonApiModule/repository.js`
 Exports
-- `createCrudJsonApiRepository({ api, resource, resourceScopeName } = {})`
+- `createCrudJsonApiRepository({ api, resource, resourceScopeName })`
 
 ### `src/server/jsonApiModule/routes.js`
 Exports
-- `normalizeCustomActionRoutes(actions = {}, namespace = "")`
-- `registerCrudJsonApiRoutes(router, { namespace, resource, routeBase = "/", relativePath, surface, ownershipFilter, access, internal = false, operations = ["list", "view", "create", "update", "delete"], actions = {}, operationInputs = {}, listFilterQueryValidator = null, routeParamsValidator = null, scopeInput = null } = {})`
+- `registerCrudJsonApiRoutes(router, { namespace, resource, routeBase, relativePath, surface, ownershipFilter, access, internal, operations, actions, operationInputs, listFilterQueryValidator, routeParamsValidator, scopeInput })`
 Local functions
-- `createScopeInput(scopeInput, request)`
-- `createCustomActionInput(scopeInput, route, request)`
+- `buildScopeInput(scopeInput, request)`
+- `buildCustomActionInput(scopeInput, route, request)`
+- `normalizeCustomActionRoutes(actions, namespace)`
 
 ### `src/server/jsonApiModule/service.js`
 Exports
-- `createCrudJsonApiService({ repository } = {})`
+- `createCrudJsonApiService({ repository })`
+- `repositoryCallOptions(options = {})`
 Local functions
-- `requireDocument(document = null)`
+- `requireDocument(document)`
 
 ### `src/server/jsonApiResourceContract.js`
 Exports
-- `resolveJsonApiFieldsetContract(resource = {})`
+- `resolveDeclaredLookupContainerKey(resource)`
+- `resolveJsonApiFieldsetContract(resource)`
 - `resolveJsonApiRelationshipEntries(definition = null)`
 - `resolveSchemaFieldDefinitions(definition = null)`
-Local functions
-- `isRecord(value)`
 
-### `src/server/listFilters.js`
+### `src/server/listFilterJsonRest.js`
 Exports
-- `CRUD_LIST_FILTER_INVALID_VALUES_REJECT`
-- `CRUD_LIST_FILTER_INVALID_VALUES_DISCARD`
-- `createCrudListFilterQueryField(filterDefinition = {}, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
-- `createCrudListFilterQuerySchema(structure = {})`
+- `normalizeColumnsMap(columns = {})`
 - `createCrudListFilterJsonRestSearchSchema(runtime = {}, { columns = {}, apply = {} } = {})`
-- `createCrudListFilters(definitions = {}, { columns = {}, apply = {} } = {})`
-- `createCrudListFilterContract(definitions = {}, { columns = {}, apply = {}, invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
+- `normalizeCrudListFilterJsonRestQuery(runtime = {}, query = {})`
 Local functions
-- `cloneTransportSchema(value)`
-- `buildSingleOrMultiTransportSchema(itemSchema)`
-- `addDaysToDateFilterValue(value = "", days = 0)`
-- `normalizeCrudListFilterQueryFieldInput(filterDefinition = null)`
-- `buildFilterQueryFieldDefinition(filterDefinition = {}, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
-- `buildFilterQueryTransportSchema(filter = {}, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
-- `buildFilterQuerySchemaDefinition(filterEntries = [], { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
-- `projectNormalizedFilterValues(filterEntries = [], source = {}, errors = {})`
-- `normalizeColumnsMap(columns = {})`
 - `resolveJsonRestFilterActualField(filter = {}, columns = {})`
 - `renderInternalJsonRestFilterKey(filter = {}, suffix = "")`
-- `createJsonRestSearchSchemaEntry({ type = "string", actualField = "", filterOperator = "=", extra = {} } = {})`
+- `buildJsonRestSearchSchemaEntry({ type = "string", actualField = "", filterOperator = "=", extra = {} } = {})`
 - `buildJsonRestFilterItemSchema(filter = {})`
 - `buildJsonRestSimpleFilterSearchSchemaEntry(filter = {}, { actualField = "" } = {})`
 - `buildJsonRestRangeFilterSearchSchemaEntries(filter = {}, { actualField = "" } = {})`
 - `buildJsonRestPresenceFilterSearchSchemaEntry(filter = {}, { actualField = "" } = {})`
-- `buildJsonRestCustomFilterSearchSchemaEntry(filter = {}, customApply = null)`
+- `buildJsonRestCustomFilterSearchSchemaEntry(filter, customApply)`
 - `resolveCrudListFilterEntries(value = {})`
 - `addJsonRestDateFilterValues(target = {}, filter = {}, value = "")`
 - `addJsonRestFilterValue(target = {}, filter = {}, value)`
-- `normalizeCrudListFilterJsonRestQuery(runtime = {}, query = {})`
+
+### `src/server/listFilters.js`
+Exports
+- `CRUD_LIST_FILTER_INVALID_VALUES_REJECT`
+- `CRUD_LIST_FILTER_INVALID_VALUES_DISCARD`
+- `buildCrudListFilterQueryField`
+- `createCrudListFilterQuerySchema`
+- `createCrudListFilterJsonRestSearchSchema`
+- `createCrudListFilters(definitions = {}, { columns = {}, apply = {} } = {})`
+- `createCrudListFilterContract(definitions = {}, { columns = {}, apply = {}, invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
+Local functions
+- `projectNormalizedFilterValues(filterEntries = [], source = {}, errors = {})`
+
+### `src/server/listFilterTypes.js`
+Exports
+- `recordIdTransportSchema`
+- `cloneTransportSchema(value)`
+- `addDaysToDateFilterValue(value = "", days = 0)`
+- `buildCrudListFilterQueryField(filterDefinition, { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
+- `createCrudListFilterQuerySchema(structure = {})`
+- `buildFilterQuerySchemaDefinition(filterEntries = [], { invalidValues = CRUD_LIST_FILTER_INVALID_VALUES_REJECT } = {})`
 - `applyDefaultFilterQuery(queryBuilder, filter = {}, value, column = "")`
+Local functions
+- `buildSingleOrMultiTransportSchema(itemSchema)`
+- `buildAllowedValuesTransportSchema({ discardInvalidValues, allowedValues })`
+- `applyEqualsFilterQuery(queryBuilder, value, column = "")`
+- `applyInFilterQuery(queryBuilder, value, column = "")`
+- `normalizeCrudListFilterQueryFieldInput(filterDefinition)`
+- `buildFilterQueryFieldDefinition(filterDefinition, { invalidValues })`
+- `buildFilterQueryTransportSchema(filter, { invalidValues })`
 
 ### `src/server/listQueryValidators.js`
 Exports
@@ -162,53 +169,27 @@ Exports
 - `listSearchQueryValidator`
 - `lookupIncludeQueryValidator`
 - `jsonApiFieldsetsQueryValidator`
-- `resolveCrudParentFilterKeys(resource = {})`
 - `createCrudParentFilterQueryValidator(resource = {})`
-- `createStandardCrudListQueryValidators({ resource = {}, listFilterQueryValidator = null, searchQueryValidator = listSearchQueryValidator, includeQueryValidator = lookupIncludeQueryValidator, fieldsetsQueryValidator = jsonApiFieldsetsQueryValidator } = {})`
+- `createStandardCrudListQueryValidators({ // readable-check: allow dependency-default - data: a resource definition resource = {}, listFilterQueryValidator = null, searchQueryValidator = listSearchQueryValidator, includeQueryValidator = lookupIncludeQueryValidator, fieldsetsQueryValidator = jsonApiFieldsetsQueryValidator } = {})`
 - `createStandardCrudViewQueryValidators({ includeQueryValidator = lookupIncludeQueryValidator, fieldsetsQueryValidator = jsonApiFieldsetsQueryValidator } = {})`
 Local functions
-- `createJsonApiFieldsetValueDefinition({ allowedFields = [] } = {})`
+- `buildJsonApiFieldsetValueDefinition({ allowedFields = [] } = {})`
 - `resolveCrudListUsesOrderedCursor(list = {})`
 
-### `src/server/lookupHydration.js`
-Exports
-- `createCrudLookupRuntime(resource = {}, { outputKeys = [] } = {})`
-- `hydrateCrudLookupRecords(records = [], runtime = {}, { include, mode = "list", repositoryOptions = {}, callOptions = {} } = {})`
-Local functions
-- `normalizeLookupRelationEntry(entry = {}, outputKeys = new Set())`
-- `normalizeLookupDefaultInclude(value)`
-- `normalizeLookupMaxDepth(value)`
-- `resolveLookupRuntimeDefaults(resource = {})`
-- `normalizeLookupIdentifier(value)`
-- `normalizeIncludePaths(include, { defaultInclude = DEFAULT_LOOKUP_INCLUDE } = {})`
-- `resolveChildIncludeFromPaths(paths = [])`
-- `buildLookupHydrationPlan(runtime = {}, include, { mode = "list", context = "crudRepository", includeWasExplicit = false, skippedNamespaces = new Set() } = {})`
-- `resolveLookupResolver(repositoryOptions = {}, callOptions = {}, { context = "crudRepository" } = {})`
-- `resolveLookupDepthRuntime(runtime = {}, repositoryOptions = {}, callOptions = {})`
-- `buildLookupGroupKey(relation = {})`
-- `normalizeLookupRelationValues(records = [], entries = [], childIncludeByKey = {})`
-- `resolveGroupChildInclude(group = {})`
-- `normalizeLookup(provider, relation = {}, { context = "crudRepository" } = {})`
-- `resolveLookupOwnershipFilter(provider = {}, { context = "crudRepository" } = {})`
-- `resolveLookupVisibilityContext(provider = {}, relation = {}, callOptions = {}, { context = "crudRepository" } = {})`
-- `buildLookupRecordMap(records = [], valueKey = "")`
-- `buildLookupCollectionMap(records = [], foreignKey = "")`
-- `resolveLookupVisitedNamespaces(runtime = {}, callOptions = {})`
-
 ### `src/server/lookupPathSupport.js`
 Exports
-- `normalizeCrudLookupApiPath`
-- `normalizeCrudLookupNamespace`
+- `normalizeLookupOwnershipFilter(value, { context })`
 - `requireCrudLookupNamespace(value = "", { context = "crudLookup" } = {})`
-- `resolveCrudLookupNamespaceFromRelation(relation = {}, { context = "crudLookup" } = {})`
 - `resolveCrudLookupToken(namespace = "", { context = "crudLookup" } = {})`
 
 ### `src/server/lookups.js`
 Exports
 - `resolveCrudLookupToken`
 - `createCrudLookup(repository, { context = "crudLookup", ownershipFilter = "" } = {})`
-Local functions
-- `normalizeLookupOwnershipFilter(value, { context = "crudLookup ownershipFilter" } = {})`
+
+### `src/server/normalizeOptionalText.js`
+Exports
+- `normalizeOptionalText(value)`
 
 ### `src/server/repositorySupport.js`
 Exports
@@ -227,115 +208,121 @@ Exports
 Local functions
 - `resolveOptionalFieldDefinitions(definition, options = {})`
 - `requireFieldDefinitions(definition, { context = "crudRepository", schemaLabel = "schema definition", defaultMode = "patch" } = {})`
-- `resolveFieldDefinitionType(definition = {})`
+- `resolveFieldDefinitionType(definition)`
 - `definitionIncludesStringType(definition = {})`
 - `definitionIncludesDateTimeType(definition = {})`
 - `definitionIncludesRecordIdType(definition = {})`
 
+### `src/server/resourceRuntime/compiledRuntime.js`
+Exports
+- `buildCompiledCrudRepositoryRuntime(resource, repositoryOptions)`
+Local functions
+- `requireCrudRepositoryOptions(value)`
+- `resolveRepositoryDefaults(resource, repositoryMapping, { context })`
+- `normalizeCrudVirtualFieldHandlers(virtualFields = {}, repositoryMapping, { context })`
+- `resolveRecordOutputValidator(resource, { context })`
+- `resolveOperationBodyValidator(resource, operationKey, { context })`
+- `normalizeCrudRepositoryOperationStage(stage, stageLabel, { context })`
+- `normalizeCrudRepositoryOperationConfig(config, operationKey, { context })`
+- `normalizeCrudRepositoryOperations(sourceOperations, { context })`
+
 ### `src/server/resourceRuntime/index.js`
 Exports
-- `createCrudResourceRuntime(resource = {}, knex, repositoryOptions = {})`
+- `createCrudResourceRuntime(resource, knex, repositoryOptions = {})`
+- `type RuntimeKnex`
+Local functions
+- `requireCrudRecordId(value, { context })`
+- `resolveCrudRepositoryCall(runtime, knex, callOptions)`
+- `applyCrudRepositoryReadLock(dbQuery, callOptions)`
+- `listRecords(runtime, knex, query, callOptions)`
+- `findRecordById(runtime, knex, recordId, callOptions)`
+- `listRecordsByIds(runtime, knex, ids, callOptions)`
+- `createRecord(runtime, knex, payload, callOptions)`
+- `updateRecordById(runtime, knex, recordId, patch, callOptions)`
+- `deleteRecordById(runtime, knex, recordId, callOptions)`
+
+### `src/server/resourceRuntime/listControls.js`
+Exports
+- `resolveListRuntimeConfig(list = {}, fallbackSearchColumns, { idColumn })`
+- `encodeOrderedListCursor(row, orderBy)`
+- `applyOrderedListCursorFilter(query, { orderBy, cursor })`
+- `enforceCrudRepositoryListControls(dbQuery, { idColumn, limit, orderBy })`
 Local functions
-- `requireCrudRecordId(value, { context = "crudRepository" } = {})`
-- `requireCrudRepositoryOptions(value = {}, { context = "crudRepository" } = {})`
-- `resolveRepositoryDefaults(resource = {}, repositoryMapping = {}, { context = "crudRepository" } = {})`
-- `normalizeCrudVirtualFieldHandlers(virtualFields = {}, repositoryMapping = {}, { context = "crudRepository" } = {})`
-- `applyCrudRepositoryVirtualProjections(dbQuery, runtime = {}, { knex, tableName } = {})`
-- `normalizeSearchColumns(searchColumns = [], fallbackColumns = [])`
+- `normalizeSearchColumns(searchColumns, fallbackColumns)`
 - `normalizeListOrderDirection(value = LIST_ORDER_DIRECTION_ASC)`
 - `normalizeListOrderNulls(value = LIST_ORDER_NULLS_LAST)`
-- `normalizeListOrderBy(orderBy = [], { idColumn = "id" } = {})`
-- `resolveListRuntimeConfig(list = {}, fallbackSearchColumns = [], { idColumn = "id" } = {})`
-- `resolveRecordOutputValidator(resource = {}, { context = "crudRepository" } = {})`
-- `resolveOperationBodyValidator(resource = {}, operationKey = "", { context = "crudRepository" } = {})`
-- `extractExplicitFieldErrors(error)`
-- `normalizeRepositoryInputPayload(runtime = {}, payload = {}, { operationKey = "create", phase = "crudCreate", action = "create", recordId = null, existingRecord = null, actionContextBase = {} } = {})`
-- `normalizeRepositoryOutputRecord(runtime = {}, record = {}, { operation = "list" } = {})`
+- `normalizeListOrderBy(orderBy, { idColumn })`
 - `encodeOrderedListCursorValue(value = null)`
 - `decodeOrderedListCursorValue(value = null)`
-- `encodeOrderedListCursor(row = null, orderBy = [])`
-- `decodeOrderedListCursor(cursor = "", orderBy = [])`
+- `decodeOrderedListCursor(cursor, orderBy)`
 - `applyOrderedListCursorEquality(query, descriptor = {}, value = null)`
 - `applyOrderedListCursorAfterBranch(query, descriptor = {}, value = null)`
 - `canApplyOrderedListCursorAfterBranch(descriptor = {}, value = null)`
 - `appendOrderedListCursorBranches(query, orderBy = [], cursorValues = [], index = 0, { useOr = false } = {})`
-- `applyOrderedListCursorFilter(query, { orderBy = [], cursor = "" } = {})`
-- `normalizeCrudRepositoryOperationStage(stage = null, stageLabel = "", { context = "crudRepository" } = {})`
-- `normalizeCrudRepositoryOperationConfig(config = {}, operationKey = "", { context = "crudRepository" } = {})`
-- `normalizeCrudRepositoryOperations(sourceOperations = {}, { context = "crudRepository" } = {})`
-- `applyConfiguredQueryStage(dbQuery, stage = null, stageContext = {}, { context = "crudRepository", stageKey = "applyQuery" } = {})`
-- `isCrudRepositoryQueryBuilder(value)`
-- `normalizeCrudRepositoryObjectInput(value = {})`
-- `applyConfiguredObjectStage(payload = {}, stage = null, stageContext = {}, { context = "crudRepository", stageKey = "preparePayload" } = {})`
-- `applyOrderedListControls(dbQuery, orderBy = [])`
-- `enforceCrudRepositoryListControls(dbQuery, { idColumn = "id", limit = DEFAULT_LIST_LIMIT + 1, orderBy = [] } = {})`
-- `createCrudRepositoryActionContextBase(runtime, callOptions = {})`
-- `createCompiledCrudRepositoryRuntime(resource = {}, repositoryOptions = {})`
-- `resolveCrudRepositoryCall(runtime, knex, callOptions = {})`
-- `applyCrudRepositoryReadLock(dbQuery, callOptions = {})`
-- `listRecords(runtime, knex, query = {}, callOptions = {})`
-- `findRecordById(runtime, knex, recordId, callOptions = {})`
-- `listRecordsByIds(runtime, knex, ids = [], callOptions = {})`
-- `createRecord(runtime, knex, payload = {}, callOptions = {})`
-- `updateRecordById(runtime, knex, recordId, patch = {}, callOptions = {})`
-- `deleteRecordById(runtime, knex, recordId, callOptions = {})`
+- `applyOrderedListControls(dbQuery, orderBy)`
 
 ### `src/server/resourceRuntime/lookupHydration.js`
 Exports
-- `createCrudLookupRuntime(resource = {}, { outputKeys = [] } = {})`
-- `hydrateCrudLookupRecords(records = [], runtime = {}, { include, mode = "list", repositoryOptions = {}, callOptions = {} } = {})`
+- `buildCrudLookupRuntime(resource, { outputKeys, context })`
+- `hydrateCrudLookupRecords(records, runtime, { include, mode, repositoryOptions, callOptions })`
+- `type LookupRuntime`
 Local functions
-- `normalizeLookupRelationEntry(entry = {}, outputKeys = new Set())`
+- `normalizeLookupRelationEntry(entry, outputKeys)`
 - `normalizeLookupDefaultInclude(value)`
 - `normalizeLookupMaxDepth(value)`
-- `resolveLookupRuntimeDefaults(resource = {})`
+- `resolveLookupRuntimeDefaults(resource)`
 - `normalizeLookupIdentifier(value)`
-- `normalizeIncludePaths(include, { defaultInclude = DEFAULT_LOOKUP_INCLUDE } = {})`
-- `resolveChildIncludeFromPaths(paths = [])`
-- `shouldHydrateByMode(entry = {}, mode = "list")`
-- `buildLookupHydrationPlan(runtime = {}, include, { mode = "list", context = "crudRepository", includeWasExplicit = false, skippedNamespaces = new Set() } = {})`
-- `resolveLookupResolver(repositoryOptions = {}, callOptions = {}, { context = "crudRepository" } = {})`
-- `resolveLookupDepthRuntime(runtime = {}, repositoryOptions = {}, callOptions = {})`
-- `buildLookupGroupKey(relation = {})`
-- `normalizeLookupRelationValues(records = [], entries = [], childIncludeByKey = {})`
-- `resolveGroupChildInclude(group = {})`
-- `normalizeLookup(provider, relation = {}, { context = "crudRepository" } = {})`
-- `resolveLookupOwnershipFilter(provider = {}, { context = "crudRepository" } = {})`
-- `resolveLookupVisibilityContext(provider = {}, relation = {}, callOptions = {}, { context = "crudRepository" } = {})`
-- `buildLookupRecordMap(records = [], valueKey = "")`
-- `buildLookupCollectionMap(records = [], foreignKey = "")`
-- `resolveLookupVisitedNamespaces(runtime = {}, callOptions = {})`
+- `normalizeIncludePaths(include, defaultInclude)`
+- `resolveChildIncludeFromPaths(paths)`
+- `shouldHydrateByMode(entry, mode)`
+- `buildLookupHydrationPlan(runtime, include, { mode, includeWasExplicit, skippedNamespaces })`
+- `resolveLookupResolver(repositoryOptions, callOptions, { context })`
+- `resolveLookupDepthRuntime(runtime, repositoryOptions, callOptions)`
+- `buildLookupGroupKey(relation)`
+- `normalizeLookupRelationValues(records, entries, childIncludeByKey)`
+- `resolveGroupChildInclude(group)`
+- `normalizeLookup(provider, relation, { context })`
+- `resolveLookupVisibilityContext(provider, relation, callOptions, { context })`
+- `buildLookupRecordMap(records, valueKey)`
+- `buildLookupCollectionMap(records, foreignKey)`
+- `resolveLookupVisitedNamespaces(runtime, callOptions)`
+
+### `src/server/resourceRuntime/operationStages.js`
+Exports
+- `applyCrudRepositoryVirtualProjections(dbQuery, runtime, { knex, tableName })`
+- `applyConfiguredQueryStage(dbQuery, stage, stageContext, { context, stageKey })`
+- `applyConfiguredObjectStage(payload, stage, stageContext, { context, stageKey })`
+- `buildCrudRepositoryActionContextBase(runtime, callOptions)`
+Local functions
+- `isCrudRepositoryQueryBuilder(value)`
+
+### `src/server/resourceRuntime/recordValidation.js`
+Exports
+- `normalizeRepositoryInputPayload(runtime, payload, operationKey)`
+- `normalizeRepositoryOutputRecord(runtime, record, { operation })`
 
 ### `src/server/routeContracts.js`
 Exports
-- `createCrudJsonApiRouteContracts({ resource = {}, routeParamsValidator = null, operations = ["list", "view", "create", "update", "delete"], operationInputs = {}, listSearchQueryValidator = defaultListSearchQueryValidator, lookupIncludeQueryValidator = defaultLookupIncludeQueryValidator, listFilterQueryValidator = null } = {})`
+- `createCrudJsonApiRouteContracts({ // readable-check: allow dependency-default - data: a resource definition resource = {}, routeParamsValidator = null, operations = ["list", "view", "create", "update", "delete"], operationInputs = {}, listSearchQueryValidator = defaultListSearchQueryValidator, lookupIncludeQueryValidator = defaultLookupIncludeQueryValidator, // readable-check: allow dependency-default - data: an optional input schema listFilterQueryValidator = null } = {})`
 - `resolveJsonApiRelationshipEntries`
 Local functions
-- `isRecord(value)`
 - `readOwnValue(source = {}, key = "")`
-- `resolveLookupContainer(record = {}, lookupContainerKey = "")`
+- `resolveLookupContainer(record, lookupContainerKey = "")`
 - `resolveRelationshipValueSource(record = {}, entry = {}, { lookupContainerKey = "", preferLookup = false } = {})`
-- `normalizeLookupId(value)`
 - `normalizeRelationshipIdentifierId(value = null)`
-- `createRelationshipIdentifier(entry = {}, value = null)`
+- `buildRelationshipIdentifier(entry = {}, value = null)`
 - `createRecordAttributesResolver(definition = null, { excludeKeys = [] } = {})`
 - `createRecordRelationshipsResolver(definition = null, { lookupContainerKey = "" } = {})`
 - `createRequestRelationshipMapper(definition = null)`
-- `resolveOutputAttributeExcludeKeys(resource = {})`
-- `resolveLookupContainerKey(resource = {})`
+- `resolveOutputAttributeExcludeKeys(resource)`
 - `normalizeIncludedLookupRecord(source = null, fallbackId = null)`
 - `appendIncludedRelationshipResource({ included = [], seen = new Set(), entry = {}, lookupRecord = null, fallbackId = null } = {})`
 - `createLookupIncludedResolver(definition = null, { lookupContainerKey = "" } = {})`
 
 ### `src/server/serviceEvents.js`
 Exports
-- `createCrudServiceEvents(resource = {}, { context = "crudService" } = {})`
-- `createCrudJsonApiServiceEvents(namespace = "", { context = "createCrudJsonApiServiceEvents" } = {})`
-- `resolveCrudEntityIdFromArgs({ args = [] } = {})`
-- `resolveCrudEntityIdFromResult({ result } = {})`
+- `buildCrudRecordChangedEvent({ namespace, operation, entityId, audience })`
 - `resolveCrudJsonApiEntityIdFromResult({ result } = {})`
-Local functions
-- `normalizeCrudEventEntityId(value = null)`
 
 ### `src/server/serviceMethods.js`
 Exports
@@ -346,9 +333,26 @@ Exports
 - `crudServiceUpdateRecord(runtime, repository, fieldAccess = {}, recordId, payload = {}, options = {})`
 - `crudServiceDeleteRecord(runtime, repository, fieldAccess = {}, recordId, options = {})`
 Local functions
-- `requireCrudServiceRepository(runtime = {}, repository = null)`
 - `splitCrudListRepositoryCall(query = {}, options = {})`
 
+### `src/server/types.js`
+Exports
+- `type CrudResourceDefinition`
+- `type CrudRepository`
+- `type CrudService`
+- `type CrudJsonApiResult`
+- `type CrudScope`
+- `type CrudResourceApi`
+- `type CrudCustomActionInvocation`
+- `type CrudLifecycleContext`
+- `type CrudLifecycleHooks`
+- `type CrudOperationLifecycle`
+- `type CrudRecordRepository`
+- `type CompiledCrudRepositoryRuntime`
+- `type CrudLookupRepository`
+- `type CrudFieldAccess`
+- `type CrudServiceRuntime`
+
 ### patterns
 
 ### `patterns/json-api-resource-package/example/migrations/20260815000000_books.cjs`
@@ -359,6 +363,10 @@ Exports
 Exports
 - `BooksFeature`
 
+### `patterns/json-api-resource-package/example/packages/books/src/server/types.js`
+Exports
+- `type AppBooks`
+
 ### `patterns/json-api-resource-package/example/packages/books/src/shared/bookResource.js`
 Exports
 - `bookResource`

package/reference/autogen/packages/database-runtime-mysql.md

@@ -25,12 +25,10 @@ Exports
 ### `src/shared/dialect.js`
 Exports
 - `DIALECT_ID`
-- `getDialectId()`
 
 ### `src/shared/index.js`
 Exports
 - `DIALECT_ID`
-- `getDialectId`
 - `introspectCrudTableSnapshot`
 
 ### `src/shared/introspectCrudTable.js`

package/reference/autogen/packages/database-runtime-postgres.md

@@ -25,12 +25,10 @@ Exports
 ### `src/shared/dialect.js`
 Exports
 - `DIALECT_ID`
-- `getDialectId()`
 
 ### `src/shared/index.js`
 Exports
 - `DIALECT_ID`
-- `getDialectId`
 
 ### patterns
 

package/reference/autogen/packages/database-runtime.md

@@ -14,31 +14,55 @@ Use this on demand; do not load the full index at startup.
 
 ### src
 
+### `src/server/database.js`
+Exports
+- `createDatabase({ driver, env })`
+Local functions
+- `resolveDriverDialectId(driver)`
+
 ### `src/server/databaseSetup.js`
 Exports
-- `prepareDatabaseFromApp({ client, appRoot = process.cwd(), environment = process.env, migrationsDirectory = "migrations", seed } = {})`
-- `runDatabaseSetup({ knex, seed, appRoot = process.cwd(), environment = process.env } = {})`
+- `prepareDatabaseFromApp({ client, appRoot = process.cwd(), environment, migrationsDirectory = "migrations", seed })`
+- `runDatabaseSetup({ knex, seed, appRoot = process.cwd(), environment })`
 Local functions
 - `normalizeMigrationResult(result)`
 
+### `src/server/foreignKeyMigrations.js`
+Exports
+- `addMissingForeignKey(knex, key)`
+- `dropForeignKeyIfPresent(knex, key)`
+- `hasForeignKey(knex, key)`
+- `type ForeignKey`
+Local functions
+- `findForeignKeyName(knex, { tableName, columnName, parentTable, parentColumn = "id" })`
+
 ### `src/server/knexFactory.js`
 Exports
 - `loadKnexFactory()`
 
 ### `src/server/knexMigrationConfig.js`
 Exports
-- `createKnexMigrationConfig({ client, environment = process.env, appRoot = process.cwd(), migrationsDirectory = "migrations", packageMigrationDirectories = [] } = {})`
-- `createKnexMigrationConfigFromApp(options = {})`
+- `createKnexMigrationConfig({ client, environment, appRoot = process.cwd(), migrationsDirectory = "migrations", // readable-check: allow dependency-default - data: a list of directory paths, not a collaborator packageMigrationDirectories = [], // readable-check: allow dependency-default - data: a list of directory paths, not a collaborator packageConstraintDirectories = [] })`
+- `createKnexMigrationConfigFromApp(options)`
 - `discoverPackageMigrationDirectories({ appRoot = process.cwd() } = {})`
 Local functions
 - `directoryExists(directory)`
+- `migrationsAfterOf({ packageId, packageMetadata }, installedPackageIds)`
+- `orderPackageMigrationDirectories(directories, packageIdOf, afterOf)`
+- `packageConstraintDirectoriesOf(packageMigrationDirectories)`
 
 ### `src/server/providers/DatabaseProvider.js`
 Exports
 - `DatabaseProvider`
-Local functions
-- `resolveDriverDialectId(driver)`
-- `createDatabase({ driver, env })`
+
+### `src/server/types.js`
+Exports
+- `type RuntimeDatabase`
+- `type RuntimeKnex`
+- `type RuntimeTransactionManager`
+- `type RuntimeKnexTransaction`
+- `type RuntimeKnexQueryBuilder`
+- `type RuntimeDatabaseDriver`
 
 ### `src/shared/databaseClient.js`
 Exports
@@ -82,6 +106,7 @@ Exports
 Exports
 - `findDuplicateEntryError(error, { dialect = "", client = null } = {})`
 - `isDuplicateEntryError(error, options)`
+- `isLostDuplicateInsertRace(error, options)`
 Local functions
 - `isMysqlDuplicateEntryError(error)`
 - `isPostgresDuplicateEntryError(error)`
@@ -101,9 +126,11 @@ Exports
 - `toKnexClientId`
 - `findDuplicateEntryError`
 - `isDuplicateEntryError`
+- `isLostDuplicateInsertRace`
 - `DEFAULT_VISIBILITY_COLUMNS`
 - `applyVisibility`
 - `applyVisibilityOwners`
+- `resolveTransaction`
 - `resolveQueryOptions`
 - `resolveRepoClient`
 - `applyForUpdate`
@@ -118,11 +145,13 @@ Exports
 - `retryDeadlocks`
 - `runInTransaction`
 - `createWithTransaction`
+- `joinOrOpenTransaction`
 - `lockScopedRecordId`
 
 ### `src/shared/repositoryOptions.js`
 Exports
-- `resolveQueryOptions(options = {})`
+- `resolveTransaction(options)`
+- `resolveQueryOptions(options)`
 - `resolveRepoClient(dbClient, options = {})`
 - `applyForUpdate(query, options = {})`
 - `parseJsonObject(value, fallback = {})`
@@ -136,14 +165,14 @@ Exports
 - `retryDeadlocks(run, { retries = 3 } = {})`
 - `runInTransaction(knex, callback, options = {})`
 - `createWithTransaction(knex)`
+- `joinOrOpenTransaction(options, withTransaction, work)`
 - `lockScopedRecordId({ trx, tableName, recordId, scopeId, idColumn = "id", scopeColumn = "workspace_id" } = {})`
 Local functions
 - `requireSqlIdentifier(value, label)`
 
 ### `src/shared/transactionManager.js`
 Exports
-- `TransactionManager`
-- `createTransactionManager(options = {})`
+- `createTransactionManager({ knex })`
 
 ### `src/shared/visibility.js`
 Exports