@manta-eu/client 0.11.0 → 0.13.0

package/src/generated/operations.ts

@@ -0,0 +1,164 @@
+export const operationRootFields: Record<string, readonly string[]> = {
+  abortUpload: ["abortUpload"],
+  AcceptInvitation: ["acceptInvitation"],
+  ActionPlanByIri: ["actionPlans"],
+  ActionPlanDiff: ["actionPlanDiff"],
+  ActionPlanRules: ["rules"],
+  ActionPlanRunHistory: ["actionPlanRunHistory"],
+  ActionPlans: ["actionPlans"],
+  ActionPlanSamples: ["actionPlanSamples"],
+  AddMemorySchemaFromTemplate: ["addMemorySchemaFromTemplate"],
+  ArchiveMemorySchema: ["archiveMemorySchema"],
+  AssignableGroups: ["assignableGroups"],
+  AssignableOrganizations: ["assignableOrganizations"],
+  AttributeStripeSubscription: ["attributeStripeSubscription"],
+  AvailableTeams: ["availableTeams"],
+  AwaitDataConnectionTest: ["awaitDataConnectionTest"],
+  BringDatastoreOnline: ["bringDatastoreOnline"],
+  CancelActionPlan: ["cancelActionPlan"],
+  ChangeManualActionAssignees: ["manualActionChangeAssignees"],
+  ClearMemorySchemaPropertyValues: ["clearMemorySchemaPropertyValues"],
+  ClearStagedRules: ["clearStagedRules"],
+  CommitStagedRules: ["commitStagedRules"],
+  CompleteStripeCheckout: ["completeStripeCheckout"],
+  completeUpload: ["completeUpload"],
+  ConnectedAccounts: ["connectedAccounts"],
+  ConnectedCustomApps: ["connectedCustomApps"],
+  ConsolidateMemories: ["consolidateMemories"],
+  ContinueDatastoreDeletion: ["continueDatastoreDeletion"],
+  ConversationStarters: ["conversationStarters"],
+  CoverageRules: ["rules"],
+  CreateCustomApp: ["createCustomApp"],
+  CreateDataConnection: ["createDataConnection"],
+  CreateInferalIntegration: ["createInferalIntegration"],
+  CreateMemory: ["createMemory"],
+  CreateMemorySchema: ["createMemorySchema"],
+  CreateStripeBillingPortalSession: ["createStripeBillingPortalSession"],
+  CreateStripeCheckoutSession: ["createStripeCheckoutSession"],
+  CurrentFactValue: ["currentFactValue"],
+  CustomApp: ["customApp"],
+  CustomAppDatastores: ["customAppDatastores"],
+  CustomApps: ["customApps"],
+  CustomAppUsers: ["customAppUsers"],
+  CustomerDatastores: ["customerDatastores"],
+  DashSetupConnect: ["dashSetupConnect"],
+  DashSetupProgress: ["dashSetupProgress"],
+  DataConnections: ["dataConnections"],
+  DataConnectorTypes: ["dataConnectorTypes"],
+  DatastoreDeletions: ["datastoreDeletions"],
+  DatastoreInvoices: ["datastoreInvoices"],
+  DatastoreProvisioningStatuses: ["datastoreProvisioningStatuses"],
+  DatastoreSubscriptions: ["datastoreSubscriptions"],
+  DatastoreTree: ["datastoreTree"],
+  DeclineInvitation: ["declineInvitation"],
+  DeleteActionPlan: ["deleteActionPlan"],
+  DeleteCustomApp: ["deleteCustomApp"],
+  DeleteDataConnection: ["deleteDataConnection"],
+  DeleteDatastore: ["deleteDatastore"],
+  DeleteLdesStream: ["deleteLDESStream"],
+  DeleteMemory: ["deleteMemory"],
+  DeleteMemorySchema: ["deleteMemorySchema"],
+  DeleteUserAccount: ["deleteUserAccount"],
+  DetectMemoryConflicts: ["detectMemoryConflicts"],
+  DisconnectConnectedAccount: ["disconnectConnectedAccount"],
+  DisconnectCustomApp: ["disconnectCustomApp"],
+  DisconnectGmailIntegration: ["disconnectGmailIntegration"],
+  DisconnectInferalIntegration: ["disconnectInferalIntegration"],
+  DismissMemorySchemaTemplateUpdate: ["dismissMemorySchemaTemplateUpdate"],
+  ExecuteAgentActionAddition: ["executeActionAddition"],
+  ExecuteAgentActionDeletion: ["executeActionDeletion"],
+  ExecuteAgentActionGraph: ["executeActionGraph"],
+  ExecuteAgentActionPlan: ["executeActionPlan"],
+  ExecuteAgentActionUpdate: ["executeActionUpdate"],
+  ExplainFact: ["explainFact"],
+  ForgetUserName: ["forgetUserName"],
+  GenerateStructuredData: ["generateStructuredData"],
+  GetActionPlansSummary: ["actionPlansSummary"],
+  GmailIntegrations: ["gmailIntegrations"],
+  GoogleAnalyticsSetupConnect: ["googleAnalyticsSetupConnect"],
+  GoogleAnalyticsSetupProgress: ["googleAnalyticsSetupProgress"],
+  GoogleBrandSuggestions: ["googleBrandSuggestions"],
+  GoogleMerchantCenterSetupConnect: ["googleMerchantCenterSetupConnect"],
+  GoogleMerchantCenterSetupProgress: ["googleMerchantCenterSetupProgress"],
+  GoogleSetupConnect: ["googleSetupConnect"],
+  GoogleSetupProgress: ["googleSetupProgress"],
+  GrantOperatorRole: ["grantOperatorRole"],
+  InferalIntegrations: ["inferalIntegrations"],
+  initiateUpload: ["initiateUpload"],
+  InviteCustomAppUser: ["inviteCustomAppUser"],
+  InviteCustomAppUsers: ["inviteCustomAppUsers"],
+  KnowledgeGraphState: ["knowledgeGraphState"],
+  LdesStreams: ["ldesStreams"],
+  LinkedinSetupConnect: ["linkedinSetupConnect"],
+  LinkedinSetupProgress: ["linkedinSetupProgress"],
+  LinkOrganizationToProvider: ["linkOrganizationToProvider"],
+  LinkUnlinkedDatastore: ["linkUnlinkedDatastore"],
+  ManualActionProgress: ["manualActionProgress"],
+  MaterializeOntologyCoverage: ["materializeOntologyCoverage"],
+  Memories: ["memories"],
+  MemoryRedundancyReview: ["memoryRedundancyReview"],
+  MemorySchemaRuleCounts: ["memorySchemaRuleCounts"],
+  MemorySchemas: ["memorySchemas"],
+  MemorySchemaTemplates: ["memorySchemaTemplates"],
+  MemorySchemaUsage: ["memorySchemaUsage"],
+  MetaInterestSuggestions: ["metaInterestSuggestions"],
+  MetaSetupConnect: ["metaSetupConnect"],
+  MetaSetupIncludePages: ["metaSetupIncludePages"],
+  MetaSetupProgress: ["metaSetupProgress"],
+  MicrosoftAdsSetupConnect: ["microsoftAdsSetupConnect"],
+  MicrosoftAdsSetupProgress: ["microsoftAdsSetupProgress"],
+  NodeProperties: ["nodeProperties"],
+  NodeRelationships: ["nodeRelationships"],
+  OrganizationLinking: ["organizationLinking"],
+  PauseLdesStream: ["pauseLDESStream"],
+  PendingInvitations: ["pendingInvitations"],
+  Profile: ["sessionContext"],
+  ProvisionDatastore: ["provisionDatastore"],
+  ReconfirmMemory: ["reconfirmMemory"],
+  RefreshResourceCapabilities: ["refreshResourceCapabilities"],
+  RefreshResources: ["refreshResources"],
+  RefreshResourcesStatus: ["refreshResourcesStatus"],
+  RegisterDatastore: ["registerDatastore"],
+  ReleaseRuleOwnership: ["releaseRuleOwnership"],
+  RemoveCustomAppUser: ["removeCustomAppUser"],
+  RemoveCustomAppUsers: ["removeCustomAppUsers"],
+  RemoveCustomAppUsersCreatedBetween: ["removeCustomAppUsersCreatedBetween"],
+  RenameDatastoreGroup: ["renameDatastoreGroup"],
+  RenameUser: ["renameUser"],
+  ResetMemorySchemaToTemplate: ["resetMemorySchemaToTemplate"],
+  ResolveManualAction: ["manualActionResolve"],
+  RestoreMemory: ["restoreMemory"],
+  ResumeLdesStream: ["resumeLDESStream"],
+  RevokeOperatorRole: ["revokeOperatorRole"],
+  RevokePreviousCustomAppSecret: ["revokePreviousCustomAppSecret"],
+  RotateCustomAppSecret: ["rotateCustomAppSecret"],
+  Rules: ["rules"],
+  SessionContext: ["sessionContext"],
+  SetActionPlanAutoPilot: ["setActionPlanAutoPilot"],
+  SetCustomAppEnabled: ["setCustomAppEnabled"],
+  ShaclShapes: ["shaclShapes"],
+  SparqlQuery: ["sparqlQuery"],
+  StageRuleOperation: ["stageRuleOperation"],
+  StartLdesStream: ["startLDESStream"],
+  StripeSubscriptionProducts: ["stripeSubscriptionProducts"],
+  SupportedActionShapes: ["supportedActionShapes"],
+  SyncGmailIntegration: ["syncGmailIntegration"],
+  TeamDirectory: ["teamDirectory"],
+  TeamGroups: ["teamGroups"],
+  TeamManagedMemberships: ["teamManagedMemberships"],
+  TeamMembers: ["teamMembers"],
+  TeamScope: ["teamScope"],
+  TenantOrganization: ["tenantOrganization"],
+  UnarchiveMemorySchema: ["unarchiveMemorySchema"],
+  UndoMemorySchemaAssignment: ["undoMemorySchemaAssignment"],
+  UnlinkedDatastores: ["unlinkedDatastores"],
+  UpdateCustomApp: ["updateCustomApp"],
+  UpdateDataConnection: ["updateDataConnection"],
+  UpdateMemory: ["updateMemory"],
+  UpdateMemorySchema: ["updateMemorySchema"],
+  UpdateUserPreferences: ["updateUserPreferences"],
+  UserPreferences: ["userPreferences"],
+  ValidateActionPlan: ["validateActionPlan"],
+  ValidateStagedRules: ["validateStagedRules"],
+  WarehouseQuery: ["warehouseQuery"],
+};

package/src/graphql-clients.ts

@@ -1,4 +1,7 @@
 import { ClientError, GraphQLClient } from "graphql-request";
+import { mantaGQLPath } from "./shared/constants";
+
+export { mantaGQLPath };
 
 // Default client constructors for the v1 and Manta GraphQL APIs
 
@@ -14,8 +17,6 @@ export function v1GraphQLClient(baseUrl: URL) {
   });
 }
 
-export const mantaGQLPath = "/graphql";
-
 // A bearer is the credential: sending cookies with it needs credentialed CORS, which only trusted origins get.
 export function mantaGraphQLCredentials(headers?: Record<string, string>): RequestCredentials {
   const sendsBearer = Object.keys(headers ?? {}).some((name) => name.toLowerCase() === "authorization");

package/src/shared/agent-types.ts

@@ -20,20 +20,36 @@ export function isRuleScopedChatContext(context: ChatContext | undefined): boole
   return context?.kind === ChatContextKind.RuleEdit || context?.kind === ChatContextKind.RuleCreate;
 }
 
+export type CachedMemorySchemaOption = {
+  value: string;
+  label: string | null;
+};
+
 export type CachedMemorySchemaProperty = {
   path: string;
   label: string;
+  description: string | null;
+  valueType: string;
   dataType: string;
   required: boolean;
+  multiValued: boolean;
   allowedValues: string[];
+  options: CachedMemorySchemaOption[];
   keyProperty: boolean;
   inferred: boolean;
+  unit: string | null;
 };
 
 export type CachedMemorySchema = {
   iri: string;
   label: string;
   description: string | null;
+  status: "active" | "archived";
+  defaultMemoryKind: string | null;
+  defaultVolatility: string | null;
+  defaultImportance: number | null;
+  extractionEnabled: boolean;
+  extractionGuidance: string | null;
   properties: CachedMemorySchemaProperty[];
 };
 

package/src/shared/chat-manager.ts

@@ -2,7 +2,7 @@ import { z } from "zod/v4";
 import { ChatContextKind } from "./agent-types";
 import type { IRI } from "./rdf-namespaces";
 
-export const chatManagerBasePath = "agents/chat-manager";
+export { chatManagerBasePath } from "./constants";
 export const chatTicketPath = "agents/chat-ticket";
 export const chatTicketQueryParam = "chat_ticket";
 export const thinkChatFacetPath = "think-chat";

package/src/shared/constants.ts

@@ -8,6 +8,16 @@ export const onboardingCompletedCookieName = "manta-onboarding-completed";
 
 export const errorRoutePath = "/error";
 
+export const mantaGQLPath = "/graphql";
+
+export const switchDatastoreRoutePath = "/api/switch-datastore";
+
+export const chatManagerBasePath = "agents/chat-manager";
+
+export const forwardedOriginHeader = "x-manta-forwarded-origin";
+
+export const authErrorParam = "auth_error";
+
 // Keycloak access tokens live 300s. Each login-status poll renews a token with at most
 // accessTokenRotationWindowMs left; window - poll (60s) absorbs background-tab timer throttling,
 // and renewing only past 180s of age keeps Keycloak refreshes to ~one per 3 min however many tabs poll.
@@ -20,3 +30,4 @@ export const memoryExtractionFlagKey = "memory-extraction-enabled";
 export const memoryAutoSupersedeFlagKey = "memory-auto-supersede-enabled";
 export const memoryReplayFlagKey = "memory-replay-enabled";
 export const memoryMaintenanceFlagKey = "memory-maintenance-enabled";
+export const memoryAutoAssignFlagKey = "memory-auto-assign-enabled";

package/src/shared/datastore-path.ts

@@ -10,6 +10,12 @@ export const redirectRoutePath = "/redirect";
 
 export const imageRoutePath = "/image";
 
+export const sparqlRoutePath = "/sparql";
+
+export const uploadedFileRoutePath = "/agents/uploads/file";
+
+export const uploadPartRoutePath = "/agents/uploads/part";
+
 export type DatastoreLocation = { datastoreId: string | undefined; path: string };
 
 const datastorePathPattern = new RegExp(`^${datastoreRoutePrefix}/([^/]+)(/.*)?$`);

package/src/shared/login-status.ts

@@ -0,0 +1 @@
+export const signedOutLoginStatus = { valid: false, canSwitchDatastore: false, allowedModels: [] };

package/src/shared/memory-schema-limits.ts

@@ -0,0 +1,16 @@
+export const memorySchemaLimits = {
+  activeSchemas: 100,
+  properties: 20,
+  options: 50,
+  label: 80,
+  key: 50,
+  description: 1000,
+  extractionGuidance: 2000,
+  propertyDescription: 500,
+  optionValue: 100,
+  optionLabel: 100,
+  optionDescription: 300,
+  unit: 30,
+  pattern: 200,
+  maxLength: 10_000,
+} as const;

package/src/shared/memory-schema-pattern.ts

@@ -0,0 +1,15 @@
+import { RE2JS } from "re2js";
+
+const compiledPatterns = new Map<string, RE2JS>();
+const compiledPatternLimit = 500;
+
+// RE2 matches in linear time, so an admin-authored pattern cannot stall a write on a long value. It lives apart from
+// the other value checks because it is large: a browser loads it only where a pattern is checked.
+export function compileMemoryValuePattern(pattern: string): RE2JS {
+  const cached = compiledPatterns.get(pattern);
+  if (cached) return cached;
+  const compiled = RE2JS.compile(pattern);
+  if (compiledPatterns.size >= compiledPatternLimit) compiledPatterns.clear();
+  compiledPatterns.set(pattern, compiled);
+  return compiled;
+}

package/src/shared/memory-schema-property.ts

@@ -0,0 +1,280 @@
+import { isPresent } from "@manta-eu/lib/present";
+import { memorySchemaLimits } from "./memory-schema-limits";
+import {
+  compareMemoryValues,
+  memorySchemaValueTypes,
+  memoryValueBoundTypes,
+  memoryValueConstraintViolation,
+  memoryValueTextTypes,
+  parseMemoryValue,
+  type CompileMemoryValuePattern,
+  type MemorySchemaValueType,
+} from "./memory-schema-values";
+import { isValidFullIri } from "./rdf-namespaces";
+
+export type MemorySchemaOptionInput = {
+  value: string;
+  label?: string | null;
+  description?: string | null;
+};
+
+export type MemorySchemaPropertyInput = {
+  path?: string | null;
+  key?: string | null;
+  label: string;
+  description?: string | null;
+  valueType: MemorySchemaValueType;
+  entityClass?: string | null;
+  required?: boolean | null;
+  multiValued?: boolean | null;
+  keyProperty?: boolean | null;
+  computed?: boolean | null;
+  options?: readonly MemorySchemaOptionInput[] | null;
+  minValue?: string | null;
+  maxValue?: string | null;
+  maxLength?: number | null;
+  pattern?: string | null;
+  defaultValue?: string | null;
+  unit?: string | null;
+};
+
+export type MemorySchemaValidationError = { field: string; message: string };
+
+export type MemorySchemaOption = { value: string; label: string | null; description: string | null };
+
+export type CheckedMemorySchemaProperty = {
+  label: string;
+  description: string | null;
+  valueType: MemorySchemaValueType;
+  entityClass: string | null;
+  required: boolean;
+  multiValued: boolean;
+  keyProperty: boolean;
+  inferred: boolean;
+  options: MemorySchemaOption[];
+  allowedValues: string[];
+  minValue: string | null;
+  maxValue: string | null;
+  maxLength: number | null;
+  pattern: string | null;
+  defaultValue: string | null;
+  unit: string | null;
+};
+
+export type MemorySchemaPropertyCheck = {
+  errors: MemorySchemaValidationError[];
+  property: CheckedMemorySchemaProperty | null;
+};
+
+const propertyKeyPattern = /^[a-z][A-Za-z0-9]*$/;
+
+function labelWords(label: string): string[] {
+  return label
+    .normalize("NFKD")
+    .replace(/[̀-ͯ]/g, "")
+    .split(/[^A-Za-z0-9]+/)
+    .filter(isPresent);
+}
+
+function capitalized(word: string): string {
+  return word.charAt(0).toUpperCase() + word.slice(1);
+}
+
+function withoutLeadingDigits(words: string[]): string[] {
+  const [first, ...rest] = words;
+  if (first === undefined) return [];
+  const stripped = first.replace(/^\d+/, "");
+  return isPresent(stripped) ? [stripped, ...rest] : withoutLeadingDigits(rest);
+}
+
+export function deriveMemorySchemaKey(label: string): string {
+  const words = withoutLeadingDigits(labelWords(label));
+  const withoutSuffix = words.at(-1)?.toLowerCase() === "memory" ? words.slice(0, -1) : words;
+  return withoutSuffix.map(capitalized).join("");
+}
+
+export function deriveMemoryPropertyKey(label: string): string {
+  const [first, ...rest] = withoutLeadingDigits(labelWords(label));
+  if (first === undefined) return "";
+  return [first.toLowerCase(), ...rest.map(capitalized)].join("");
+}
+
+export function memoryPropertyKeyProblem(key: string): string | null {
+  if (!propertyKeyPattern.test(key)) {
+    return "A property key starts with a lowercase letter and holds only letters and digits";
+  }
+  if (key.length > memorySchemaLimits.key) return `A property key must be at most ${memorySchemaLimits.key} characters`;
+  return null;
+}
+
+export function trimmedOrNull(value: string | null | undefined): string | null {
+  const trimmed = value?.trim() ?? "";
+  return isPresent(trimmed) ? trimmed : null;
+}
+
+type Add = (field: string, message: string) => void;
+
+function checkLength(add: Add, field: string, value: string | null, max: number, name: string): void {
+  if (value !== null && [...value].length > max) add(field, `${name} must be at most ${max} characters`);
+}
+
+function checkOptions(add: Add, field: string, input: readonly MemorySchemaOptionInput[]): MemorySchemaOption[] {
+  if (input.length > memorySchemaLimits.options) {
+    add(field, `A property takes at most ${memorySchemaLimits.options} allowed values`);
+  }
+  const seen = new Set<string>();
+  return input.map((option, index) => {
+    const value = option.value.trim();
+    const label = trimmedOrNull(option.label);
+    const description = trimmedOrNull(option.description);
+    const optionField = `${field}.${index}`;
+    if (!isPresent(value)) add(`${optionField}.value`, "An allowed value cannot be empty");
+    if (seen.has(value)) add(`${optionField}.value`, `"${value}" is listed twice`);
+    seen.add(value);
+    checkLength(add, `${optionField}.value`, value, memorySchemaLimits.optionValue, "An allowed value");
+    checkLength(add, `${optionField}.label`, label, memorySchemaLimits.optionLabel, "An option label");
+    checkLength(
+      add,
+      `${optionField}.description`,
+      description,
+      memorySchemaLimits.optionDescription,
+      "An option description",
+    );
+    return { value, label, description };
+  });
+}
+
+function checkBound(
+  add: Add,
+  field: string,
+  valueType: MemorySchemaValueType,
+  raw: string | null | undefined,
+): string | null {
+  const trimmed = trimmedOrNull(raw);
+  if (trimmed === null) return null;
+  if (!memoryValueBoundTypes.includes(valueType)) {
+    add(field, "Only number, date and date-time properties take a minimum or maximum");
+    return null;
+  }
+  const parsed = parseMemoryValue(valueType, trimmed);
+  if (parsed === null) add(field, `"${trimmed}" is not a valid ${valueType} value`);
+  return parsed;
+}
+
+function isValueType(value: string): value is MemorySchemaValueType {
+  return memorySchemaValueTypes.some((valueType) => valueType === value);
+}
+
+export function checkMemorySchemaProperty(
+  input: Omit<MemorySchemaPropertyInput, "valueType"> & { valueType: string },
+  field: string,
+  compilePattern: CompileMemoryValuePattern | null,
+): MemorySchemaPropertyCheck {
+  const errors: MemorySchemaValidationError[] = [];
+  const add: Add = (at, message) => errors.push({ field: at, message });
+
+  const label = input.label.trim();
+  if (!isPresent(label)) add(`${field}.label`, "A property needs a label");
+  checkLength(add, `${field}.label`, label, memorySchemaLimits.label, "A property label");
+
+  if (!isValueType(input.valueType)) {
+    add(`${field}.valueType`, `Unknown value type ${String(input.valueType)}`);
+    return { errors, property: null };
+  }
+  const valueType = input.valueType;
+
+  const description = trimmedOrNull(input.description);
+  checkLength(add, `${field}.description`, description, memorySchemaLimits.propertyDescription, "A description");
+
+  const entityClass = trimmedOrNull(input.entityClass);
+  if (entityClass !== null && valueType !== "entity") {
+    add(`${field}.entityClass`, "Only an entity reference takes an entity class");
+  }
+  if (entityClass !== null && !isValidFullIri(entityClass)) {
+    add(`${field}.entityClass`, "The entity class must be a full IRI");
+  }
+
+  const multiValued = input.multiValued === true;
+  const keyProperty = input.keyProperty === true;
+  const inferred = input.computed === true;
+  const required = input.required === true;
+  if (keyProperty && multiValued) add(`${field}.keyProperty`, "A key property must hold a single value");
+  if (keyProperty && valueType === "longText") add(`${field}.keyProperty`, "Long text cannot be a key property");
+  if (keyProperty && inferred) add(`${field}.keyProperty`, "A computed property cannot be a key property");
+  if (required && inferred) add(`${field}.required`, "A computed property cannot be required");
+
+  const options = checkOptions(add, `${field}.options`, input.options ?? []);
+  if (isPresent(options) && valueType !== "text") {
+    add(`${field}.options`, "Only text properties take a list of allowed values");
+  }
+
+  const minValue = checkBound(add, `${field}.minValue`, valueType, input.minValue);
+  const maxValue = checkBound(add, `${field}.maxValue`, valueType, input.maxValue);
+  if (minValue !== null && maxValue !== null && compareMemoryValues(valueType, minValue, maxValue) > 0) {
+    add(`${field}.maxValue`, "The maximum must not be below the minimum");
+  }
+
+  const takesLength = [...memoryValueTextTypes, "url"].includes(valueType);
+  const maxLength = input.maxLength ?? null;
+  if (maxLength !== null) {
+    if (!takesLength) {
+      add(`${field}.maxLength`, "Only text and URL properties take a maximum length");
+    } else if (!Number.isInteger(maxLength) || maxLength < 1 || maxLength > memorySchemaLimits.maxLength) {
+      add(`${field}.maxLength`, `The maximum length must be between 1 and ${memorySchemaLimits.maxLength}`);
+    }
+  }
+
+  const pattern = trimmedOrNull(input.pattern);
+  if (pattern !== null) {
+    checkLength(add, `${field}.pattern`, pattern, memorySchemaLimits.pattern, "A pattern");
+    if (!memoryValueTextTypes.includes(valueType)) {
+      add(`${field}.pattern`, "Only text properties take a pattern");
+    } else if (compilePattern !== null) {
+      try {
+        compilePattern(pattern);
+      } catch {
+        add(`${field}.pattern`, "The pattern is not a valid regular expression");
+      }
+    }
+  }
+
+  const unit = trimmedOrNull(input.unit);
+  checkLength(add, `${field}.unit`, unit, memorySchemaLimits.unit, "A unit");
+  if (unit !== null && valueType !== "integer" && valueType !== "decimal") {
+    add(`${field}.unit`, "Only number properties take a unit");
+  }
+
+  const property: CheckedMemorySchemaProperty = {
+    label,
+    description,
+    valueType,
+    entityClass: valueType === "entity" ? entityClass : null,
+    required,
+    multiValued,
+    keyProperty,
+    inferred,
+    options,
+    allowedValues: options.map((option) => option.value),
+    minValue,
+    maxValue,
+    maxLength: takesLength ? maxLength : null,
+    pattern,
+    defaultValue: null,
+    unit,
+  };
+
+  const rawDefault = trimmedOrNull(input.defaultValue);
+  if (rawDefault !== null) {
+    if (inferred) {
+      add(`${field}.defaultValue`, "A computed property cannot have a default value");
+    } else {
+      const parsed = parseMemoryValue(valueType, rawDefault);
+      const violation = parsed === null ? null : memoryValueConstraintViolation(property, parsed, compilePattern);
+      if (parsed === null) add(`${field}.defaultValue`, `"${rawDefault}" is not a valid ${valueType} value`);
+      else if (violation !== null) add(`${field}.defaultValue`, `The default value ${violation}`);
+      else property.defaultValue = parsed;
+    }
+  }
+
+  return { errors, property };
+}