@@ -0,0 +1 @@
+pub(crate) mod name_parts;
@@ -0,0 +1,30 @@
+//! Fixed-width ASCII segments of reserved relation names.
+
+/// The rest of `name` after an ASCII case-insensitive `prefix`.
+pub(crate) fn strip_prefix_folded<'a>(name: &'a str, prefix: &str) -> Option<&'a str> {
+    let head: &str = name.get(..prefix.len())?;
+    head.eq_ignore_ascii_case(prefix)
+        .then(|| name.get(prefix.len()..))
+        .flatten()
+}
+
+/// `width` leading ASCII digits as a number, and the rest of `text`.
+pub(crate) fn leading_number(text: &str, width: usize) -> Option<(u32, &str)> {
+    let digits: &str = text.get(..width)?;
+    if !digits.bytes().all(|byte| byte.is_ascii_digit()) {
+        return None;
+    }
+    let value: u32 = digits
+        .bytes()
+        .fold(0, |total, byte| total * 10 + u32::from(byte - b'0'));
+    Some((value, text.get(width..)?))
+}
+
+/// The rest of `text` after one ASCII case-insensitive `marker` character.
+pub(crate) fn after_marker(text: &str, marker: char) -> Option<&str> {
+    let mut characters = text.chars();
+    characters
+        .next()
+        .filter(|character| character.eq_ignore_ascii_case(&marker))
+        .map(|_| characters.as_str())
+}
@@ -0,0 +1,69 @@
+//! Janitor planning names, prefixes and skip reasons.
+
+/// SQLBuild state tables the janitor never acts on.
+pub const BUILT_IN_EXCLUDE_PATTERNS: [&str; 9] = [
+    "_sqlbuild_fingerprints",
+    "_sqlbuild_microbatches",
+    "_sqlbuild_source_freshness",
+    "_sqlbuild_node_results",
+    "_sqlbuild_audit_results",
+    "_sqlbuild_janitor_events",
+    "_sqlbuild_migrations",
+    "_sqlbuild_column_migrations",
+    "_sqlbuild_old_name_views",
+];
+/// Prefix of every strict janitor archive name.
+pub const ARCHIVE_NAME_PREFIX: &str = "_SQB_ARCHIVE__";
+/// Separator between archive name segments.
+pub const ARCHIVE_NAME_SEPARATOR: &str = "__";
+/// Folded prefix reserving a name for janitor archive handling.
+pub const ARCHIVE_LOOKALIKE_PREFIX: &str = "_sqb_archive";
+/// Label used in archive name fitting errors.
+pub const ARCHIVE_ARTIFACT_LABEL: &str = "Janitor archive";
+/// Reason for names that may require quoting.
+pub const UNQUOTED_ADDRESSING_REASON: &str = "relation name is not a plain lowercase identifier and may require quoting; janitor does not act on it";
+/// Reason for names that collide case-insensitively.
+pub const CASE_COLLISION_REASON: &str =
+    "relation name collides case-insensitively with another relation; janitor does not act on it";
+/// Reason for archive lookalikes outside the strict grammar.
+pub const MALFORMED_ARCHIVE_REASON: &str =
+    "name resembles a janitor archive but does not match the strict archive grammar";
+/// Reason for query-diff artifacts left to fingerprint expiry cleanup.
+pub const QUERY_DIFF_ARTIFACT_REASON: &str = "query-diff artifacts use fingerprint expiry cleanup";
+/// Reason for reserved query-diff names without ownership evidence.
+pub const UNTRACKED_QUERY_DIFF_REASON: &str =
+    "reserved query-diff name lacks matching ownership evidence";
+/// Default reason for protected relations.
+pub const PROTECTED_REASON: &str = "relation is protected from cleanup";
+/// Reason for relations without a SQLBuild fingerprint.
+pub const UNTRACKED_REASON: &str = "relation is not tracked by SQLBuild";
+/// Reason when the adapter has no relation age metadata.
+pub const AGE_UNSUPPORTED_REASON: &str = "adapter does not expose relation age metadata";
+/// Reason when a relation's age is unknown.
+pub const AGE_UNAVAILABLE_REASON: &str = "relation age is unavailable";
+/// Reason protecting compatibility views at old model names.
+pub const OLD_NAME_VIEW_REASON: &str = "compatibility view at an old model name";
+/// Parts of a fully qualified migration origin.
+pub const QUALIFIED_ORIGIN_PARTS: usize = 3;
+/// Default janitor relation retention in days.
+pub const DEFAULT_RETENTION_DAYS: i64 = 14;
+/// Prefix of reserved query-diff artifact names.
+pub const QUERY_DIFF_ARTIFACT_PREFIX: &str = "__sqlbuild_query_diff_";
+/// Sides a query-diff artifact may hold.
+pub const QUERY_DIFF_SIDES: [&str; 2] = ["left", "right"];
+/// Hex digits ending a query-diff run id.
+pub const ARTIFACT_RUN_HEX_DIGITS: usize = 12;
+/// Digits of a year in a compact UTC timestamp.
+pub const YEAR_DIGITS: usize = 4;
+/// Digits of a month or day in a compact UTC timestamp.
+pub const DATE_DIGITS: usize = 2;
+/// Digits of an hour, minute or second in a compact UTC timestamp.
+pub const TIME_DIGITS: usize = 2;
+/// Largest month number.
+pub const LAST_MONTH: u32 = 12;
+/// Largest hour.
+pub const LAST_HOUR: u32 = 23;
+/// Largest minute.
+pub const LAST_MINUTE: u32 = 59;
+/// Largest second; leap seconds are rejected as Python's `datetime` rejects them.
+pub const LAST_SECOND: u32 = 59;
@@ -0,0 +1,33 @@
+//! Fitted, case-folded janitor archive names.
+
+use crate::identifier_fitting::main::fit_artifact_logical_name::fit_artifact_logical_name;
+use crate::janitor_planning::constants::{
+    ARCHIVE_ARTIFACT_LABEL, ARCHIVE_NAME_PREFIX, ARCHIVE_NAME_SEPARATOR,
+};
+use crate::janitor_planning::models::ArchiveTimestamp;
+
+/// The archive name keeping prefix, timestamp and kind intact; `Err` carries the fitting error.
+pub fn build_archive_name(
+    (original_name, archived_at): (&str, ArchiveTimestamp),
+    identifier_limit: i64,
+    kind: Option<&str>,
+) -> Result<String, String> {
+    let kind_segment: String = kind.map_or_else(String::new, |kind| {
+        format!("{kind}{ARCHIVE_NAME_SEPARATOR}")
+    });
+    let fixed_prefix: String = format!(
+        "{ARCHIVE_NAME_PREFIX}{:04}{:02}{:02}T{:02}{:02}{:02}Z{ARCHIVE_NAME_SEPARATOR}{kind_segment}",
+        archived_at.year,
+        archived_at.month,
+        archived_at.day,
+        archived_at.hour,
+        archived_at.minute,
+        archived_at.second,
+    );
+    let logical_part: String = fit_artifact_logical_name(
+        (original_name, &fixed_prefix),
+        identifier_limit,
+        ARCHIVE_ARTIFACT_LABEL,
+    )?;
+    Ok(format!("{fixed_prefix}{logical_part}").to_lowercase())
+}
@@ -0,0 +1,16 @@
+//! Folded names shared by several relations in one listing.
+
+use std::collections::{HashMap, HashSet};
+
+/// Case-folded names that occur more than once in `names`.
+pub fn case_colliding_names<'a>(names: impl IntoIterator<Item = &'a str>) -> HashSet<String> {
+    let mut counts: HashMap<String, usize> = HashMap::new();
+    for name in names {
+        *counts.entry(name.to_lowercase()).or_insert(0) += 1;
+    }
+    counts
+        .into_iter()
+        .filter(|(_, count)| *count > 1)
+        .map(|(name, _)| name)
+        .collect()
+}
@@ -0,0 +1,16 @@
+//! Relations whose folded name is shared in their listing.
+
+use std::collections::HashSet;
+
+use crate::janitor_planning::constants::CASE_COLLISION_REASON;
+
+/// Why a relation must not be dropped because its folded name collides, if it does.
+#[must_use]
+pub fn case_collision_reason(
+    name: &str,
+    colliding_names: &HashSet<String>,
+) -> Option<&'static str> {
+    colliding_names
+        .contains(&name.to_lowercase())
+        .then_some(CASE_COLLISION_REASON)
+}
@@ -0,0 +1,9 @@
+//! Names reserved for janitor archive handling.
+
+use crate::janitor_planning::constants::ARCHIVE_LOOKALIKE_PREFIX;
+
+/// Whether a relation name starts, ignoring case, with the archive prefix.
+#[must_use]
+pub fn is_archive_lookalike_name(name: &str) -> bool {
+    name.to_lowercase().starts_with(ARCHIVE_LOOKALIKE_PREFIX)
+}
@@ -0,0 +1,20 @@
+//! Janitor exclude patterns matched against relation and qualified names.
+
+use sqlbuild_core::text::main::glob_match::glob_match;
+
+/// The first pattern matching the name or the qualified display name, ignoring case.
+#[must_use]
+pub fn matching_exclude_pattern<'a>(
+    (name, display_name): (&str, &str),
+    patterns: &'a [String],
+) -> Option<&'a str> {
+    let name: String = name.to_lowercase();
+    let display_name: String = display_name.to_lowercase();
+    patterns
+        .iter()
+        .find(|pattern| {
+            let folded: String = pattern.to_lowercase();
+            glob_match(&name, &folded) || glob_match(&display_name, &folded)
+        })
+        .map(String::as_str)
+}
@@ -0,0 +1,41 @@
+//! Relations a `migrate_from` value may name.
+
+use crate::janitor_planning::constants::QUALIFIED_ORIGIN_PARTS;
+use crate::janitor_planning::models::OriginKey;
+
+/// Origin keys for `raw`: a bare name in each sorted schema, else the one qualified relation.
+#[must_use]
+pub fn migration_origin_keys(
+    raw: &str,
+    destination_database: Option<&str>,
+    sorted_schemas: &[(Option<String>, Option<String>)],
+) -> Vec<OriginKey> {
+    let parts: Vec<String> = raw
+        .split('.')
+        .map(|part| {
+            part.trim()
+                .trim_matches(|c| c == '"' || c == '`')
+                .to_owned()
+        })
+        .collect();
+    if let [name] = parts.as_slice() {
+        return sorted_schemas
+            .iter()
+            .map(|(database, schema)| OriginKey {
+                database: database.clone(),
+                schema: schema.clone(),
+                name: name.clone(),
+            })
+            .collect();
+    }
+    let count: usize = parts.len();
+    vec![OriginKey {
+        database: if count == QUALIFIED_ORIGIN_PARTS {
+            Some(parts[0].clone())
+        } else {
+            destination_database.map(str::to_owned)
+        },
+        schema: Some(parts[count - 2].clone()),
+        name: parts[count - 1].clone(),
+    }]
+}
@@ -0,0 +1,11 @@
+pub mod build_archive_name;
+pub mod case_colliding_names;
+pub mod case_collision_reason;
+pub mod is_archive_lookalike_name;
+pub mod matching_exclude_pattern;
+pub mod migration_origin_keys;
+pub mod old_name_request_matches;
+pub mod parse_archive_name;
+pub mod query_diff_artifact_parts;
+pub mod resolve_retention_days;
+pub mod unaddressable_relation_reason;