From 58462d584462f780080f8f8e72b0a8b9a4e3c4be Mon Sep 17 00:00:00 2001 From: Hare Date: Wed, 7 Oct 2026 00:14:51 +0900 Subject: [PATCH] feat: register Workspace Profiles as Decodal values (T-710) Project the evaluated Workspace Profile value into a revision-bound JSON archive without source-path registration or Decodal re-evaluation. Preserve partial-value omissions and explicit overrides, validate before save, and reject legacy registrations with a documented explicit migration. Fix array-element schema completion and provide fingerprint-bound authoring shapes independently of materialization defaults. Carry metadata through REST, regenerate TypeScript/OpenAPI/WASM artifacts, and exercise save/projection/Runtime consumption and persisted Manifest restore boundaries. Validation: root cargo check; cargo test -p config-source; cargo test -p worker-runtime; cargo test -p server-api --features typescript; focused profile_settings/value_profiles/archive tests; 39 web config-source/profile API tests; deno task check; cargo fmt --all -- --check; git diff --check HEAD. Full workspace-server test: 641 passed, one pre-existing ticket_checker_suppresses_stale_and_clean_results_and_diagnoses_invalid_output assertion failure. The same filter fails at base 3c424fd17d1a5e8bb5542de2d0ad88f55338e0ea in a separately archived source tree and isolated target directory. Remaining server crate tests pass with only that filter skipped (641 lib + 11 bin); unrelated checker code is unchanged. --- crates/config-source/src/lib.rs | 688 +++++++++++++++++- crates/server-api/src/lib.rs | 4 + crates/worker-runtime/src/profile_archive.rs | 274 ++++++- crates/workspace-server/src/config_source.rs | 6 +- .../workspace-server/src/profile_settings.rs | 393 ++++------ crates/workspace-server/src/server.rs | 2 + .../src/server/tests/subjektiv_jobs_tests.rs | 2 +- .../src/server/tests/value_profiles_tests.rs | 362 +++++++++ docs/design/profiles-manifests-prompts.md | 30 +- openapi/server-api.json | 9 +- .../config-schema/profile-authoring.dcdl | 72 ++ resources/config-schema/profile.dcdl | 11 + web/workspace/deno.json | 2 +- .../src/lib/generated/companion-api.ts | 2 +- .../src/lib/generated/legacy-server-api.ts | 4 + .../src/lib/generated/repository-api.ts | 2 +- .../src/lib/generated/runtime-api.ts | 2 +- web/workspace/src/lib/generated/ticket-api.ts | 2 +- .../src/lib/generated/worker-launch-api.ts | 2 +- .../src/lib/workspace/config-source/api.ts | 8 +- .../generated/config_source_wasm_bg.wasm | Bin 1265992 -> 1283030 bytes .../types/ConfigSchemaContribution.ts | 2 +- web/workspace/test/config-source/api.test.ts | 38 + .../test/config-source/wasm-parity.test.ts | 110 +++ 24 files changed, 1708 insertions(+), 319 deletions(-) create mode 100644 crates/workspace-server/src/server/tests/value_profiles_tests.rs create mode 100644 resources/config-schema/profile-authoring.dcdl create mode 100644 resources/config-schema/profile.dcdl diff --git a/crates/config-source/src/lib.rs b/crates/config-source/src/lib.rs index a5df85dce..2d6604d82 100644 --- a/crates/config-source/src/lib.rs +++ b/crates/config-source/src/lib.rs @@ -487,6 +487,9 @@ pub struct ConfigSchemaContribution { pub namespace: String, pub version: String, pub source: String, + // Optional editor-only schema; never used to validate or materialize config. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub authoring_source: Option, #[serde(default, skip_serializing_if = "Option::is_none")] pub projection_validator: Option, pub source_digest: String, @@ -529,16 +532,31 @@ impl ConfigSchemaContribution { version, source_digest: digest_bytes(source.as_bytes()), source, + authoring_source: None, projection_validator: None, }) } + pub fn with_authoring_source(mut self, source: impl Into) -> Self { + self.authoring_source = Some(source.into()); + self + } + pub fn with_projection_validator(mut self, validator: ConfigProjectionValidator) -> Self { self.projection_validator = Some(validator); self } fn validate(&self) -> Result<(), ConfigTreeError> { + if self + .authoring_source + .as_ref() + .is_some_and(|source| source.trim().is_empty()) + { + return Err(ConfigTreeError::InvalidSchemaContribution( + "authoring schema source must not be empty".to_string(), + )); + } let expected = digest_bytes(self.source.as_bytes()); if self.source_digest != expected { return Err(ConfigTreeError::InvalidSchemaContribution(format!( @@ -591,27 +609,41 @@ impl WorkspaceConfigSchemaBundle { .collect::>() .join(" & ") }; - let fingerprint = digest_bytes( - serde_json::to_vec(&( - CONFIG_SOURCE_CONTRACT_VERSION, - DECODAL_VERSION, - contributions - .iter() - .map(|contribution| { - ( - contribution.provider_id.as_str(), - contribution.namespace.as_str(), - contribution.version.as_str(), - contribution.source_digest.as_str(), - contribution.projection_validator.as_ref(), - ) - }) - .collect::>(), - digest_bytes(source.as_bytes()), - )) - .expect("schema bundle fingerprint input serializes") - .as_slice(), - ); + let mut fingerprint_input = serde_json::to_vec(&( + CONFIG_SOURCE_CONTRACT_VERSION, + DECODAL_VERSION, + contributions + .iter() + .map(|contribution| { + ( + contribution.provider_id.as_str(), + contribution.namespace.as_str(), + contribution.version.as_str(), + contribution.source_digest.as_str(), + contribution.projection_validator.as_ref(), + ) + }) + .collect::>(), + digest_bytes(source.as_bytes()), + )) + .expect("schema bundle fingerprint input serializes"); + let authoring_sources = contributions + .iter() + .filter_map(|contribution| { + contribution + .authoring_source + .as_deref() + .map(|source| (contribution.provider_id.as_str(), source)) + }) + .collect::>(); + // Preserve legacy fingerprints when no editor-only metadata is present. + if !authoring_sources.is_empty() { + fingerprint_input.extend( + serde_json::to_vec(&("authoring_sources", authoring_sources)) + .expect("authoring schema fingerprint input serializes"), + ); + } + let fingerprint = digest_bytes(&fingerprint_input); Ok(Self { contributions, source, @@ -619,6 +651,25 @@ impl WorkspaceConfigSchemaBundle { }) } + fn authoring_source(&self) -> String { + if self.contributions.is_empty() { + return self.source.clone(); + } + self.contributions + .iter() + .map(|contribution| { + format!( + "({})", + contribution + .authoring_source + .as_deref() + .unwrap_or(&contribution.source) + ) + }) + .collect::>() + .join(" & ") + } + pub fn empty() -> Self { Self::compose(Vec::new()).expect("empty schema bundle is valid") } @@ -751,26 +802,32 @@ pub struct EvaluationResult { pub projection_digest: String, } +#[derive(Debug, Clone, PartialEq, Eq)] +enum ConfigCompletionPathSegment { + Field(String), + Index(usize), +} + #[derive(Debug, Clone, PartialEq, Eq)] struct ConfigFieldCompletionContext { - schema_path: Vec, + schema_path: Vec, from: usize, } #[derive(Debug)] enum ConfigCompletionContainer { Object { - schema_path: Vec, + schema_path: Vec, pending_path: Vec, last_identifier_from: Option, trailing_dot: bool, reading_value: bool, }, Array { - schema_path: Vec, + schema_path: Vec, }, Other { - schema_path: Vec, + schema_path: Vec, }, } @@ -855,9 +912,18 @@ fn config_field_completion_context( }); } SyntaxTokenKind::LBracket => { - let schema_path = pending_container_path(&containers); + let mut schema_path = pending_container_path(&containers); + schema_path.push(ConfigCompletionPathSegment::Index(0)); containers.push(ConfigCompletionContainer::Array { schema_path }); } + SyntaxTokenKind::Comma => { + if let Some(ConfigCompletionContainer::Array { schema_path }) = + containers.last_mut() + && let Some(ConfigCompletionPathSegment::Index(index)) = schema_path.last_mut() + { + *index += 1; + } + } SyntaxTokenKind::RBracket => { pop_container(&mut containers, |container| { matches!(container, ConfigCompletionContainer::Array { .. }) @@ -943,7 +1009,12 @@ fn config_field_completion_context( return None; }; let mut schema_path = schema_path.clone(); - schema_path.extend(pending_path.iter().cloned()); + schema_path.extend( + pending_path + .iter() + .cloned() + .map(ConfigCompletionPathSegment::Field), + ); Some(ConfigFieldCompletionContext { schema_path, from: if *trailing_dot { @@ -954,14 +1025,25 @@ fn config_field_completion_context( }) } -fn pending_container_path(containers: &[ConfigCompletionContainer]) -> Vec { +fn pending_container_path( + containers: &[ConfigCompletionContainer], +) -> Vec { match containers.last() { Some(ConfigCompletionContainer::Object { schema_path, pending_path, reading_value: true, .. - }) => schema_path.iter().chain(pending_path).cloned().collect(), + }) => schema_path + .iter() + .cloned() + .chain( + pending_path + .iter() + .cloned() + .map(ConfigCompletionPathSegment::Field), + ) + .collect(), Some(ConfigCompletionContainer::Array { schema_path }) | Some(ConfigCompletionContainer::Other { schema_path }) => schema_path.clone(), _ => Vec::new(), @@ -1201,12 +1283,37 @@ impl SnapshotEnvironment { if self.schema_bundle.is_some() && let Some(context) = config_field_completion_context(source, utf8_byte_offset) { - let mut member_source = format!("{WORKSPACE_CONFIG_SCHEMA_GLOBAL}."); - member_source.push_str(&context.schema_path.join(".")); - if !context.schema_path.is_empty() && context.from == utf8_byte_offset { - member_source.push('.'); + let (schema_path, prefix) = if context.from == utf8_byte_offset { + (context.schema_path.as_slice(), "") + } else { + let Some((ConfigCompletionPathSegment::Field(prefix), schema_path)) = + context.schema_path.split_last() + else { + return self.complete(entrypoint, source, utf8_byte_offset, explicit); + }; + (schema_path, prefix.as_str()) + }; + let has_array = schema_path + .iter() + .any(|segment| matches!(segment, ConfigCompletionPathSegment::Index(_))); + let mut member_source = WORKSPACE_CONFIG_SCHEMA_GLOBAL.to_owned(); + // Ordinary object paths retain the language service's member traversal, + // but both branches install the composed authoring schema. + if !has_array { + for segment in schema_path { + if let ConfigCompletionPathSegment::Field(field) = segment { + member_source.push('.'); + member_source.push_str(field); + } + } } - let mut completion = LanguageService::new(self).complete( + member_source.push('.'); + member_source.push_str(prefix); + let completion_environment = ConfigFieldCompletionEnvironment { + environment: self, + schema_path: if has_array { schema_path } else { &[] }, + }; + let mut completion = LanguageService::new(completion_environment).complete( entrypoint.as_str(), &member_source, member_source.len(), @@ -1270,6 +1377,91 @@ impl HostEnvironment for &SnapshotEnvironment { } } +// Decodal has no indexed member syntax. Resolve array ranges only in this +// completion environment, then reuse the language service's member behavior. +struct ConfigFieldCompletionEnvironment<'a> { + environment: &'a SnapshotEnvironment, + schema_path: &'a [ConfigCompletionPathSegment], +} + +impl HostEnvironment for ConfigFieldCompletionEnvironment<'_> { + type Loader = SnapshotImportLoader; + + fn create_loader(&self) -> Self::Loader { + self.environment.create_loader() + } + + fn configure_engine(&self, engine: &mut Engine) -> decodal::Result<()> { + use decodal::runtime::{ConcreteValue, ObjectField, ObjectValue, RuntimeValue}; + + let Some(bundle) = &self.environment.schema_bundle else { + return Ok(()); + }; + let module = engine.add_root_source( + WORKSPACE_CONFIG_SCHEMA_SOURCE, + WORKSPACE_CONFIG_SCHEMA_SOURCE, + &bundle.authoring_source(), + )?; + let mut schema = Some(engine.eval_module(module)?); + for segment in self.schema_path { + let Some(value) = schema else { + break; + }; + schema = match segment { + ConfigCompletionPathSegment::Field(field) => engine + .value_fields(&value)? + .unwrap_or_default() + .into_iter() + .find(|(name, _)| name == field) + .map(|(_, value)| value), + ConfigCompletionPathSegment::Index(index) => { + let element = match value { + RuntimeValue::Concrete(ConcreteValue::Array(elements)) => { + elements.get(*index).copied() + } + RuntimeValue::Abstract(range) => { + range.constraints.iter().find_map(|entry| { + if let decodal::Constraint::ArrayItems(element) = entry.constraint { + Some(element) + } else { + None + } + }) + } + _ => None, + }; + if let Some(element) = element { + // value_fields is the public API for forcing lazy fields. + // Wrap the element thunk without materializing its schema. + let object = RuntimeValue::Concrete(ConcreteValue::Object(ObjectValue { + fields: vec![ObjectField { + name: "element".into(), + value: element, + span: Span::default(), + }], + rest: None, + })); + engine + .value_fields(&object)? + .and_then(|fields| fields.into_iter().next().map(|(_, value)| value)) + } else { + None + } + } + }; + } + if let Some(schema) = schema { + engine.bind_global_runtime(WORKSPACE_CONFIG_SCHEMA_GLOBAL, schema); + } else { + engine.bind_global( + WORKSPACE_CONFIG_SCHEMA_GLOBAL, + Value::object([] as [(&str, Value); 0]), + )?; + } + Ok(()) + } +} + #[derive(Debug, Clone)] pub struct SnapshotImportLoader { snapshot: ConfigTreeSnapshot, @@ -1890,7 +2082,7 @@ mod tests { assert_eq!( config_field_completion_context(root, root_cursor), Some(ConfigFieldCompletionContext { - schema_path: vec!["pro".into()], + schema_path: vec![ConfigCompletionPathSegment::Field("pro".into())], from: root_cursor - 3, }) ); @@ -1899,7 +2091,10 @@ mod tests { assert_eq!( config_field_completion_context(nested, nested_cursor), Some(ConfigFieldCompletionContext { - schema_path: vec!["profile".into(), "def".into()], + schema_path: vec![ + ConfigCompletionPathSegment::Field("profile".into()), + ConfigCompletionPathSegment::Field("def".into()), + ], from: nested_cursor - 3, }) ); @@ -1908,7 +2103,12 @@ mod tests { assert_eq!( config_field_completion_context(array, array_cursor), Some(ConfigFieldCompletionContext { - schema_path: vec!["profile".into(), "entries".into(), "sel".into()], + schema_path: vec![ + ConfigCompletionPathSegment::Field("profile".into()), + ConfigCompletionPathSegment::Field("entries".into()), + ConfigCompletionPathSegment::Index(0), + ConfigCompletionPathSegment::Field("sel".into()), + ], from: array_cursor - 3, }) ); @@ -1991,6 +2191,420 @@ mod tests { ); } + fn profile_entries_completion_schema() -> WorkspaceConfigSchemaBundle { + WorkspaceConfigSchemaBundle::compose([ConfigSchemaContribution::new( + "builtin:profile", + "profile", + "1", + "{ profile = { default_profile = String; entries = [...{ selector = String; profile = { slug = String; worker = { mode = String; }; }; }]; }; }", + ) + .unwrap()]) + .unwrap() + } + + #[test] + fn completion_projects_array_element_and_nested_profile_fields() { + let snapshot = ConfigTreeSnapshot::from_entries(1, [entry("main.dcdl", "{}")]).unwrap(); + let environment = SnapshotEnvironment::new(snapshot) + .with_schema_bundle(profile_entries_completion_schema()); + for (marked_source, expected, prefix_len) in [ + ( + "{ profile.entries = [{ sel| }] } as WorkspaceConfigSchema", + "selector", + 3, + ), + ( + "{ profile = { entries = [{ pro| }] } } as WorkspaceConfigSchema", + "profile", + 3, + ), + ( + "{ profile.entries = [{ | }] } as WorkspaceConfigSchema", + "selector", + 0, + ), + ( + "{ profile.entries = [{ | }] } as WorkspaceConfigSchema", + "profile", + 0, + ), + ( + "{ profile.entries = [{ profile = { slu| } }] } as WorkspaceConfigSchema", + "slug", + 3, + ), + ( + "{ profile.entries = [{ profile = { | } }] } as WorkspaceConfigSchema", + "worker", + 0, + ), + ( + "{ profile.entries = [{ profile.worker.mo| }] } as WorkspaceConfigSchema", + "mode", + 2, + ), + ( + "{ profile.entries = [{ profile.worker.| }] } as WorkspaceConfigSchema", + "mode", + 0, + ), + ( + "{ profile.entries = [{ profile = { worker = { mo| } } }] } as WorkspaceConfigSchema", + "mode", + 2, + ), + ( + "{ profile.entries = [{}, { sel| }] } as WorkspaceConfigSchema", + "selector", + 3, + ), + ( + "{ profile.entries = [{ selector = \"日本語\"; profile = { slu|g } }] } as WorkspaceConfigSchema", + "slug", + 3, + ), + ( + "{ profile.entries = [{ pro|file }] } as WorkspaceConfigSchema", + "profile", + 3, + ), + ( + "{ profile.entries = [({ profile = { worker = { mo| } } })] } as WorkspaceConfigSchema", + "mode", + 2, + ), + ] { + let cursor = marked_source.find('|').unwrap(); + let source = marked_source.replace('|', ""); + let completion = environment + .complete_config(&path("main.dcdl"), &source, cursor, true) + .unwrap() + .unwrap_or_else(|| panic!("missing completion for {marked_source}")); + assert_eq!(completion.from, cursor - prefix_len, "{marked_source}"); + assert!( + completion.items.iter().any(|item| item.label == expected), + "{marked_source}: {completion:?}" + ); + } + } + + #[test] + fn completion_tracks_fixed_array_positions_and_nested_array_ranges() { + let snapshot = ConfigTreeSnapshot::from_entries(1, [entry("main.dcdl", "{}")]).unwrap(); + let schema = WorkspaceConfigSchemaBundle::compose([ConfigSchemaContribution::new( + "builtin:profile", + "profile", + "1", + "{ profile = { entries = [{ selector = String; }, { profile = { slug = String; worker = { mode = String; }; }; }]; matrix = [...[...{ selector = String; }]]; }; }", + ) + .unwrap()]) + .unwrap(); + let environment = SnapshotEnvironment::new(snapshot).with_schema_bundle(schema); + for (marked_source, expected, unexpected) in [ + ( + "{ profile.entries = [{ | }] } as WorkspaceConfigSchema", + "selector", + "profile", + ), + ( + "{ profile.entries = [{}, { | }] } as WorkspaceConfigSchema", + "profile", + "selector", + ), + ( + "{ profile.entries = [{}, { profile.worker.mo| }] } as WorkspaceConfigSchema", + "mode", + "selector", + ), + ( + "{ profile.matrix = [[{}, { sel| }]] } as WorkspaceConfigSchema", + "selector", + "profile", + ), + ( + "{ profile.matrix = [[], [{ sel| }]] } as WorkspaceConfigSchema", + "selector", + "profile", + ), + ] { + let cursor = marked_source.find('|').unwrap(); + let source = marked_source.replace('|', ""); + let completion = environment + .complete_config(&path("main.dcdl"), &source, cursor, true) + .unwrap() + .unwrap_or_else(|| panic!("missing completion for {marked_source}")); + assert!( + completion.items.iter().any(|item| item.label == expected), + "{marked_source}: {completion:?}" + ); + assert!( + !completion.items.iter().any(|item| item.label == unexpected), + "{marked_source}: {completion:?}" + ); + } + for marked_source in [ + "{ profile.entries = [{}, {}, { | }] } as WorkspaceConfigSchema", + "{ profile.entries = [{ missing = { | } }] } as WorkspaceConfigSchema", + ] { + let cursor = marked_source.find('|').unwrap(); + let source = marked_source.replace('|', ""); + let completion = environment + .complete_config(&path("main.dcdl"), &source, cursor, true) + .unwrap(); + assert!( + completion.is_none_or(|completion| !completion + .items + .iter() + .any(|item| matches!(item.label.as_str(), "selector" | "profile"))), + "{marked_source}" + ); + } + } + + #[test] + fn completion_preserves_general_schema_member_behavior() { + let snapshot = ConfigTreeSnapshot::from_entries(1, [entry("main.dcdl", "{}")]).unwrap(); + let environment = SnapshotEnvironment::new(snapshot) + .with_schema_bundle(profile_entries_completion_schema()); + for source in [ + "WorkspaceConfigSchema.pro", + "WorkspaceConfigSchema.profile.", + "WorkspaceConfigSchema.profile.entries.", + "WorkspaceConfigSchema.profile.default_pro", + "let schema = WorkspaceConfigSchema; in schema.profile.def", + ] { + assert_eq!( + environment + .complete_config(&path("main.dcdl"), source, source.len(), true) + .unwrap(), + environment + .complete(&path("main.dcdl"), source, source.len(), true) + .unwrap(), + "{source}" + ); + } + } + + #[test] + fn completion_array_schema_retains_nested_profile_diagnostics() { + let valid = "{ profile = { default_profile = \"default\"; entries = [{ selector = \"default\"; profile = { slug = \"default\"; worker = { mode = \"interactive\"; }; }; }]; }; } as WorkspaceConfigSchema"; + let snapshot = ConfigTreeSnapshot::from_entries(7, [entry("main.dcdl", valid)]).unwrap(); + let environment = SnapshotEnvironment::new(snapshot) + .with_schema_bundle(profile_entries_completion_schema()); + assert!(environment.analyze(&path("main.dcdl"), None).is_empty()); + for (source, field) in [ + ( + valid.replace("selector = \"default\"", "selector = 42"), + "selector", + ), + (valid.replace("slug = \"default\"", "slug = 42"), "slug"), + (valid.replace("mode = \"interactive\"", "mode = 42"), "mode"), + ( + valid.replace("mode = \"interactive\"", "typo = \"interactive\""), + "typo", + ), + ] { + let diagnostics = environment.analyze(&path("main.dcdl"), Some(&source)); + assert!( + diagnostics.iter().any(|diagnostic| { + diagnostic.kind == "constraint_violation" + && diagnostic.path == path("main.dcdl") + && diagnostic.revision == 7 + && diagnostic.span.end_byte > diagnostic.span.start_byte + && (diagnostic.message.contains(field) + || diagnostic + .labels + .iter() + .any(|label| label.message.contains(field))) + }), + "{field}: {diagnostics:#?}" + ); + } + } + + #[test] + fn completion_authoring_schema_preserves_omitted_profile_fields_in_evaluation() { + let schema = WorkspaceConfigSchemaBundle::compose([ConfigSchemaContribution::new( + "builtin:profile", + "profile", + "1", + "{ profile = { defaults = {...Unknown}; entries = [...{ selector = String; profile = {...Unknown}; }]; }; }", + ) + .unwrap() + .with_authoring_source( + "{ profile = { defaults = { slug = String; worker = { mode = String; }; }; entries = [...{ selector = String; profile = { slug = String; worker = { mode = String; }; }; }]; }; }", + )]) + .unwrap(); + let source = "{ profile = { defaults = {}; entries = [{ selector = \"default\"; profile = {}; }]; }; } as WorkspaceConfigSchema"; + let snapshot = ConfigTreeSnapshot::from_entries(1, [entry("main.dcdl", source)]).unwrap(); + let environment = SnapshotEnvironment::new(snapshot).with_schema_bundle(schema.clone()); + assert!(environment.analyze(&path("main.dcdl"), None).is_empty()); + let contract = ToolchainContract::with_schema_bundle(1, vec![path("main.dcdl")], 1, schema); + let evaluated = environment.evaluate_contract(&contract).unwrap(); + assert_eq!( + evaluated.projections[0].data_json, + serde_json::json!({"profile": {"defaults": {}, "entries": [{"selector": "default", "profile": {}}]}}) + ); + // Both ordinary object paths and array-element paths use editor metadata. + for (marked_source, expected) in [ + ( + "{ profile.defaults = { slu| } } as WorkspaceConfigSchema", + "slug", + ), + ( + "{ profile.defaults.worker = { mo| } } as WorkspaceConfigSchema", + "mode", + ), + ( + "{ profile.entries = [{ pro| }] } as WorkspaceConfigSchema", + "profile", + ), + ( + "{ profile.entries = [{ profile = { slu| } }] } as WorkspaceConfigSchema", + "slug", + ), + ( + "{ profile.entries = [{ profile.worker = { mo| } }] } as WorkspaceConfigSchema", + "mode", + ), + ( + "{ profile.entries = [{ profile = { | } }] } as WorkspaceConfigSchema", + "worker", + ), + ] { + let cursor = marked_source.find('|').unwrap(); + let source = marked_source.replace('|', ""); + let completion = environment + .complete_config(&path("main.dcdl"), &source, cursor, true) + .unwrap() + .unwrap_or_else(|| panic!("missing completion for {marked_source}")); + assert!( + completion.items.iter().any(|item| item.label == expected), + "{marked_source}: {completion:?}" + ); + } + // Completion does not install its schema into later analysis/evaluation. + assert!(environment.analyze(&path("main.dcdl"), None).is_empty()); + assert_eq!(environment.evaluate_contract(&contract).unwrap(), evaluated); + } + + #[test] + fn completion_authoring_sources_compose_with_validation_source_fallbacks() { + let schema = WorkspaceConfigSchemaBundle::compose([ + ConfigSchemaContribution::new( + "builtin:editor", + "editor", + "1", + "{ editor = {...Unknown}; }", + ) + .unwrap() + .with_authoring_source( + "{ editor = { theme = String; settings = { enabled = Bool; }; }; }", + ), + ConfigSchemaContribution::new( + "builtin:web", + "web", + "1", + "{ web = { enabled = Bool; }; }", + ) + .unwrap(), + ]) + .unwrap(); + let snapshot = ConfigTreeSnapshot::from_entries(1, [entry("main.dcdl", "{}")]).unwrap(); + let environment = SnapshotEnvironment::new(snapshot).with_schema_bundle(schema); + for (marked_source, expected) in [ + ("{ ed| } as WorkspaceConfigSchema", "editor"), + ("{ editor = { th| } } as WorkspaceConfigSchema", "theme"), + ( + "{ editor.settings = { en| } } as WorkspaceConfigSchema", + "enabled", + ), + ("{ web = { en| } } as WorkspaceConfigSchema", "enabled"), + ] { + let cursor = marked_source.find('|').unwrap(); + let source = marked_source.replace('|', ""); + let completion = environment + .complete_config(&path("main.dcdl"), &source, cursor, true) + .unwrap() + .unwrap(); + assert!( + completion.items.iter().any(|item| item.label == expected), + "{marked_source}: {completion:?}" + ); + } + } + + #[test] + fn authoring_schema_metadata_is_optional_validated_and_fingerprinted() { + let contribution = ConfigSchemaContribution::new( + "builtin:editor", + "editor", + "1", + "{ editor = {...Unknown}; }", + ) + .unwrap(); + let serialized = serde_json::to_value(&contribution).unwrap(); + assert!(serialized.get("authoring_source").is_none()); + assert_eq!( + serde_json::from_value::(serialized).unwrap(), + contribution + ); + let legacy = WorkspaceConfigSchemaBundle::compose([contribution.clone()]).unwrap(); + let legacy_input = serde_json::to_vec(&( + CONFIG_SOURCE_CONTRACT_VERSION, + DECODAL_VERSION, + vec![( + contribution.provider_id.as_str(), + contribution.namespace.as_str(), + contribution.version.as_str(), + contribution.source_digest.as_str(), + contribution.projection_validator.as_ref(), + )], + digest_bytes(legacy.source.as_bytes()), + )) + .unwrap(); + assert_eq!(legacy.fingerprint, digest_bytes(&legacy_input)); + legacy.validate().unwrap(); + + let authoring = contribution + .clone() + .with_authoring_source("{ editor = { theme = String; }; }"); + assert_eq!(authoring.source_digest, contribution.source_digest); + let serialized = serde_json::to_value(&authoring).unwrap(); + assert_eq!( + serialized["authoring_source"], + "{ editor = { theme = String; }; }" + ); + assert_eq!( + serde_json::from_value::(serialized).unwrap(), + authoring + ); + let authored = WorkspaceConfigSchemaBundle::compose([authoring]).unwrap(); + authored.validate().unwrap(); + assert_eq!(authored.source, legacy.source); + assert_ne!(authored.fingerprint, legacy.fingerprint); + assert_ne!( + ToolchainContract::with_schema_bundle(1, vec![path("main.dcdl")], 1, authored.clone()) + .fingerprint, + ToolchainContract::with_schema_bundle(1, vec![path("main.dcdl")], 1, legacy) + .fingerprint, + ); + let changed = WorkspaceConfigSchemaBundle::compose([contribution + .clone() + .with_authoring_source("{ editor = { theme = String; mode = String; }; }")]) + .unwrap(); + assert_ne!(changed.fingerprint, authored.fingerprint); + let mut tampered = authored; + tampered.contributions[0].authoring_source = + changed.contributions[0].authoring_source.clone(); + assert!(tampered.validate().is_err()); + for source in ["", " \n\t "] { + assert!( + matches!(WorkspaceConfigSchemaBundle::compose([contribution.clone().with_authoring_source(source)]), Err(ConfigTreeError::InvalidSchemaContribution(message)) if message.contains("authoring")) + ); + } + } + #[test] fn relative_imports_and_completion_share_the_snapshot_namespace() { let snapshot = ConfigTreeSnapshot::from_entries( diff --git a/crates/server-api/src/lib.rs b/crates/server-api/src/lib.rs index 0062c3bc5..65c717d8b 100644 --- a/crates/server-api/src/lib.rs +++ b/crates/server-api/src/lib.rs @@ -4496,6 +4496,10 @@ pub struct ConfigSchemaContribution { #[serde(default, skip_serializing_if = "Option::is_none")] #[cfg_attr(feature = "typescript", ts(optional))] pub projection_validator: Option, + /// Completion-only shape for partial values; never materialized as defaults. + #[serde(default, skip_serializing_if = "Option::is_none")] + #[cfg_attr(feature = "typescript", ts(optional))] + pub authoring_source: Option, pub source_digest: String, } diff --git a/crates/worker-runtime/src/profile_archive.rs b/crates/worker-runtime/src/profile_archive.rs index 6c056b878..a38ff72dd 100644 --- a/crates/worker-runtime/src/profile_archive.rs +++ b/crates/worker-runtime/src/profile_archive.rs @@ -125,6 +125,35 @@ pub struct ProfileSourceArchiveInput { impl ProfileSourceArchive { pub fn build(input: ProfileSourceArchiveInput) -> Result { + Self::build_with_source_format(input, "decodal", "text/x-decodal") + } + + /// Archive an already evaluated Profile value without Decodal evaluation or conversion. + pub fn build_evaluated_profile( + id: String, + selector: String, + value: serde_json::Value, + ) -> Result { + let path = "profiles/evaluated.json".to_string(); + let source = serde_json::to_string(&value) + .map_err(|err| ProfileArchiveError::Json(err.to_string()))?; + Self::build_with_source_format( + ProfileSourceArchiveInput { + id, + entrypoints: BTreeMap::from([(selector, path.clone())]), + imports: BTreeMap::new(), + sources: BTreeMap::from([(path, source)]), + }, + "json", + "application/json", + ) + } + + fn build_with_source_format( + input: ProfileSourceArchiveInput, + kind: &str, + content_type: &str, + ) -> Result { if input.sources.len() > MAX_SOURCES { return Err(ProfileArchiveError::LimitExceeded("source count")); } @@ -145,8 +174,8 @@ impl ProfileSourceArchive { source_meta.push(ProfileSourceArchiveSource { path: path.clone(), source_key: path.clone(), - kind: "decodal".to_string(), - content_type: default_decodal_content_type(), + kind: kind.to_string(), + content_type: content_type.to_string(), digest: sha256_hex(source.as_bytes()), size_bytes: size, }); @@ -288,7 +317,17 @@ impl VerifiedProfileSourceArchive { actual: source.source_key.clone(), }); } - if source.content_type != default_decodal_content_type() { + let expected_content_type = match source.kind.as_str() { + "decodal" => "text/x-decodal", + "json" => "application/json", + _ => { + return Err(ProfileArchiveError::UnsupportedSource { + path: source.path.clone(), + kind: source.kind.clone(), + }); + } + }; + if source.content_type != expected_content_type { return Err(ProfileArchiveError::UnsupportedSource { path: source.path.clone(), kind: source.content_type.clone(), @@ -297,12 +336,6 @@ impl VerifiedProfileSourceArchive { if !manifest_paths.insert(source.path.clone()) { return Err(ProfileArchiveError::DuplicateSource(source.path.clone())); } - if source.kind != "decodal" { - return Err(ProfileArchiveError::UnsupportedSource { - path: source.path.clone(), - kind: source.kind.clone(), - }); - } let content = entries .get(&source.path) .ok_or_else(|| ProfileArchiveError::MissingSource(source.path.clone()))?; @@ -373,30 +406,50 @@ impl VerifiedProfileSourceArchive { .entrypoints .get(selector) .ok_or_else(|| ProfileArchiveError::MissingEntrypoint(selector.to_string()))?; - let mut engine = Engine::new(ArchiveSourceLoader { archive: self }); let source = self .sources .get(path) .ok_or_else(|| ProfileArchiveError::MissingSource(path.clone()))?; - let module = engine.add_root_source(path, path, source).map_err(|err| { - ProfileArchiveError::Decodal { - path: path.clone(), - message: format!("{err:?}"), + let metadata = self + .manifest + .sources + .iter() + .find(|source| &source.path == path) + .ok_or_else(|| ProfileArchiveError::MissingSource(path.clone()))?; + let json = match metadata.kind.as_str() { + "json" => serde_json::from_str(source) + .map_err(|err| ProfileArchiveError::Json(err.to_string()))?, + "decodal" => { + let mut engine = Engine::new(ArchiveSourceLoader { archive: self }); + let module = engine.add_root_source(path, path, source).map_err(|err| { + ProfileArchiveError::Decodal { + path: path.clone(), + message: format!("{err:?}"), + } + })?; + let value = + engine + .eval_module(module) + .map_err(|err| ProfileArchiveError::Decodal { + path: path.clone(), + message: format!("{err:?}"), + })?; + let data = + engine + .materialize(&value) + .map_err(|err| ProfileArchiveError::Decodal { + path: path.clone(), + message: format!("{err:?}"), + })?; + decodal_data_to_json(&data) } - })?; - let value = engine - .eval_module(module) - .map_err(|err| ProfileArchiveError::Decodal { - path: path.clone(), - message: format!("{err:?}"), - })?; - let data = engine - .materialize(&value) - .map_err(|err| ProfileArchiveError::Decodal { - path: path.clone(), - message: format!("{err:?}"), - })?; - let json = decodal_data_to_json(&data); + _ => { + return Err(ProfileArchiveError::UnsupportedSource { + path: path.clone(), + kind: metadata.kind.clone(), + }); + } + }; let resolved = resolve_profile_artifact_value( json, ProfileSource::Archive { @@ -674,6 +727,171 @@ mod tests { .unwrap() } + fn evaluated_profile() -> serde_json::Value { + serde_json::json!({ + "slug": "evaluated", + "description": "Evaluated profile", + "scope": "workspace_read", + "worker": { "mode": "wip" }, + "feature": { + "task": { "enabled": true }, + "memory": { "enabled": true }, + "sub_worker": { "enabled": true } + } + }) + } + + fn evaluated_archive() -> ProfileSourceArchive { + ProfileSourceArchive::build_evaluated_profile( + "evaluated-archive".to_string(), + "project:evaluated".to_string(), + evaluated_profile(), + ) + .unwrap() + } + + #[test] + fn evaluated_json_preserves_explicit_worker_mode_and_features() { + let archive = evaluated_archive(); + let verified = archive.verify().unwrap(); + let source = &verified.manifest().sources[0]; + assert_eq!(source.kind, "json"); + assert_eq!(source.content_type, "application/json"); + assert_eq!(verified.manifest().imports.len(), 0); + assert_eq!( + serde_json::from_str::(&verified.sources[&source.path]).unwrap(), + evaluated_profile() + ); + let root = tempfile::tempdir().unwrap(); + let manifest = verified + .resolve_profile("project:evaluated", root.path(), "evaluated-worker") + .unwrap(); + let json = serde_json::to_value(&manifest).unwrap(); + assert_eq!(manifest.worker.name, "evaluated-worker"); + assert_eq!(json["worker"]["mode"], "wip"); + assert_eq!(json["feature"]["task"]["enabled"], true); + assert_eq!(json["feature"]["memory"]["profile"]["enabled"], true); + assert_eq!(json["feature"]["sub_worker"]["enabled"], true); + } + + // Recompute the outer digest so verification reaches the source-level checks. + fn repack_archive( + archive: &mut ProfileSourceArchive, + manifest: &ProfileSourceArchiveManifest, + sources: &BTreeMap, + ) { + let mut content = Vec::new(); + { + let mut builder = Builder::new(&mut content); + append_bytes( + &mut builder, + MANIFEST_PATH, + &serde_json::to_vec(manifest).unwrap(), + ) + .unwrap(); + for (path, source) in sources { + append_bytes(&mut builder, path, source.as_bytes()).unwrap(); + } + builder.finish().unwrap(); + } + archive.reference.digest = sha256_hex(&content); + archive.reference.size_bytes = content.len() as u64; + archive.content = content; + } + + #[test] + fn evaluated_json_reuses_source_size_limit() { + assert!(matches!( + ProfileSourceArchive::build_evaluated_profile( + "oversized".to_string(), + "default".to_string(), + serde_json::Value::String("x".repeat(MAX_SOURCE_BYTES as usize)), + ), + Err(ProfileArchiveError::LimitExceeded("source bytes")) + )); + } + + #[test] + fn evaluated_json_rejects_archive_and_source_tampering() { + let mut archive = evaluated_archive(); + archive.content[0] ^= 1; + assert!(matches!( + archive.verify(), + Err(ProfileArchiveError::ArchiveDigestMismatch { .. }) + )); + + let mut archive = evaluated_archive(); + let mut verified = archive.verify().unwrap(); + let path = verified.manifest.sources[0].path.clone(); + verified + .sources + .get_mut(&path) + .unwrap() + .replace_range(0..1, "["); + repack_archive(&mut archive, &verified.manifest, &verified.sources); + assert!(matches!( + archive.verify(), + Err(ProfileArchiveError::SourceDigestMismatch { path: actual, .. }) if actual == path + )); + } + + #[test] + fn evaluated_json_requires_matching_source_kind_and_content_type() { + for (kind, content_type) in [ + ("json", "text/x-decodal"), + ("decodal", "application/json"), + ("unknown", "application/json"), + ] { + let mut archive = evaluated_archive(); + let mut verified = archive.verify().unwrap(); + verified.manifest.sources[0].kind = kind.to_string(); + verified.manifest.sources[0].content_type = content_type.to_string(); + repack_archive(&mut archive, &verified.manifest, &verified.sources); + assert!(matches!( + archive.verify(), + Err(ProfileArchiveError::UnsupportedSource { .. }) + )); + } + } + + #[test] + fn evaluated_json_does_not_fallback_to_filesystem_or_default() { + let root = tempfile::tempdir().unwrap(); + let profiles = root.path().join("profiles"); + std::fs::create_dir(&profiles).unwrap(); + let local_profile = profiles.join("evaluated.json"); + std::fs::write( + &local_profile, + serde_json::to_vec(&evaluated_profile()).unwrap(), + ) + .unwrap(); + let verified = evaluated_archive().verify().unwrap(); + for selector in [ + "default", + "profiles/evaluated.json", + local_profile.to_str().unwrap(), + ] { + assert!(matches!( + verified.resolve_profile(selector, root.path(), "evaluated-worker"), + Err(ProfileArchiveError::MissingEntrypoint(actual)) if actual == selector + )); + } + + // A valid local file must not rescue an invalid archived Profile value either. + let invalid = ProfileSourceArchive::build_evaluated_profile( + "invalid".to_string(), + "project:evaluated".to_string(), + serde_json::json!({ "not_a_profile_field": true }), + ) + .unwrap() + .verify() + .unwrap(); + assert!(matches!( + invalid.resolve_profile("project:evaluated", root.path(), "evaluated-worker"), + Err(ProfileArchiveError::Profile { .. }) + )); + } + #[test] fn build_and_verify_archive() { let archive = sample_archive(); diff --git a/crates/workspace-server/src/config_source.rs b/crates/workspace-server/src/config_source.rs index 2a127bd9c..19d566416 100644 --- a/crates/workspace-server/src/config_source.rs +++ b/crates/workspace-server/src/config_source.rs @@ -140,7 +140,11 @@ pub(crate) fn validate_workspace_config_candidate_projections( }; crate::prompt_settings::validate_evaluated_prompt_catalog(&candidate.evaluation)?; if has_provider("builtin:profile") { - crate::profile_settings::project_profiles_from_workspace_config(workspace_id, &state)?; + crate::profile_settings::project_profiles_from_evaluation( + workspace_id, + &state, + &candidate.evaluation, + )?; } if has_provider("builtin:runtime") { crate::runtime_settings::project_runtime_from_workspace_config(workspace_id, &state)?; diff --git a/crates/workspace-server/src/profile_settings.rs b/crates/workspace-server/src/profile_settings.rs index 5c38a099b..2d08b2e31 100644 --- a/crates/workspace-server/src/profile_settings.rs +++ b/crates/workspace-server/src/profile_settings.rs @@ -1,7 +1,7 @@ use std::collections::BTreeMap; -use std::path::{Component, Path, PathBuf}; +use std::path::Path; -use config_source::{ConfigContentType, ConfigSchemaContribution, VirtualPath}; +use config_source::ConfigSchemaContribution; use manifest::{ProfileSource, builtin_profile_catalog_snapshot, resolve_profile_artifact_value}; use serde::Deserialize; use server_api::{ @@ -21,24 +21,19 @@ use crate::config_source::{ use crate::store::WorkspaceRecord; use crate::{Error, Result}; -const PROFILE_SCHEMA_SOURCE: &str = r#"{ - profile = { - default_profile = String default "builtin:companion"; - entries = [...{ - selector = String; - source = String; - label = String default ""; - description = String default ""; - }] default []; - }; -}"#; +const PROFILE_SCHEMA_SOURCE: &str = include_str!("../../../resources/config-schema/profile.dcdl"); #[derive(Debug, Default)] pub struct ProfileConfigSchemaProvider; impl WorkspaceConfigSchemaProvider for ProfileConfigSchemaProvider { fn contribution(&self) -> Result { - ConfigSchemaContribution::new("builtin:profile", "profile", "1", PROFILE_SCHEMA_SOURCE) + ConfigSchemaContribution::new("builtin:profile", "profile", "2", PROFILE_SCHEMA_SOURCE) + .map(|schema| { + schema.with_authoring_source(include_str!( + "../../../resources/config-schema/profile-authoring.dcdl" + )) + }) .map_err(|error| Error::Config(error.to_string())) } } @@ -59,7 +54,7 @@ struct VirtualProfileSection { #[serde(deny_unknown_fields)] struct VirtualProfileEntry { selector: String, - source: String, + profile: serde_json::Value, label: String, description: String, } @@ -68,7 +63,6 @@ struct VirtualProfileEntry { pub struct ProfileConfigProjection { pub settings: ProfileSettingsResponse, entries: BTreeMap, - sources: BTreeMap, } pub fn project_profiles_from_workspace_config( @@ -96,23 +90,42 @@ pub fn project_profiles_from_workspace_config( "Profile projection digest mismatch for Workspace {workspace_id}" ))); } + project_profiles_from_evaluation(workspace_id, state, &evaluation) +} + +pub(crate) fn project_profiles_from_evaluation( + workspace_id: &str, + state: &WorkspaceConfigState, + evaluation: &config_source::EvaluationResult, +) -> Result { + if evaluation.projection_digest != state.projection_digest { + return Err(Error::Config( + "Profile evaluation does not match Workspace config state".into(), + )); + } let projected = evaluation.projections.first().ok_or_else(|| { Error::RegistryInconsistency("Workspace config has no active projection".to_string()) })?; + if projected + .data_json + .pointer("/profile/entries") + .and_then(serde_json::Value::as_array) + .is_some_and(|entries| entries.iter().any(|entry| entry.get("source").is_some())) + { + return Err(profile_validation_error( + "profile_source_registration_removed", + "profile.entries.source is no longer supported: replace source = \"profiles/name.dcdl\" with profile = import \"./profiles/name.dcdl\" (relative to the containing config file). Saved config is not rewritten.", + )); + } let config: VirtualProfileConfig = serde_json::from_value(projected.data_json.clone()) .map_err(|error| Error::RegistryInconsistency(error.to_string()))?; let mut profiles = builtin_profile_summaries(Some(&config.profile.default_profile)); let mut entries = BTreeMap::new(); - let sources = state - .snapshot - .entries - .iter() - .filter(|(_, entry)| entry.content_type == ConfigContentType::Decodal) - .map(|(path, entry)| (path.as_str().to_string(), entry.content.clone())) - .collect::>(); let mut source_summaries = Vec::new(); for entry in config.profile.entries { - if !entry.selector.starts_with("project:") { + if !entry.selector.starts_with("project:") + || entry.selector.trim_start_matches("project:").is_empty() + { return Err(profile_validation_error( "profile_selector_invalid", "Workspace Profile selectors must use project:*", @@ -124,61 +137,43 @@ pub fn project_profiles_from_workspace_config( "Workspace Profile selectors must be unique", )); } - let source_path = VirtualPath::parse(&entry.source).map_err(|error| { - profile_validation_error("profile_source_path_invalid", &error.to_string()) - })?; - let source_entry = state.snapshot.get(&source_path).ok_or_else(|| { - profile_validation_error( - "profile_source_missing", - &format!( - "Profile source {:?} is missing from the active config revision", - entry.source - ), - ) - })?; - if source_entry.content_type != ConfigContentType::Decodal { - return Err(profile_validation_error( - "profile_source_type_invalid", - "Profile sources must use Decodal content", - )); - } - let archive_source = entry.source.clone(); let label = if entry.label.is_empty() { entry.selector.trim_start_matches("project:").to_string() } else { entry.label.clone() }; resolve_profile_artifact_value( - evaluate_profile_source(&state.snapshot, &source_path)?, + entry.profile.clone(), ProfileSource::Archive { archive_id: format!("workspace-config-r{}", state.snapshot.revision), - source: archive_source.clone(), + source: entry.selector.clone(), }, Path::new("/"), "workspace-config-validation", ) - .map_err(|error| profile_validation_error("profile_source_invalid", &error.to_string()))?; + .map_err(|error| profile_validation_error("profile_value_invalid", &error.to_string()))?; profiles.push(WorkspaceProfileSummary { profile_id: entry.selector.clone(), selector: entry.selector.clone(), label, source_kind: "project".to_string(), - profile_source_id: Some(entry.source.clone()), + profile_source_id: Some(entry.selector.clone()), description: (!entry.description.is_empty()).then(|| entry.description.clone()), editable: false, is_default: config.profile.default_profile == entry.selector, diagnostics: Vec::new(), }); + let value_bytes = serde_json::to_vec(&entry.profile).expect("Profile value serializes"); source_summaries.push(WorkspaceProfileSourceSummary { - profile_source_id: entry.source.clone(), - display_path: entry.source.clone(), - kind: "virtual_config".to_string(), - content_type: "decodal".to_string(), - content_digest: source_entry.content_digest.clone(), + profile_source_id: entry.selector.clone(), + display_path: format!("profile.entries[{}].profile", source_summaries.len()), + kind: "evaluated_config".to_string(), + content_type: "application/json".to_string(), + content_digest: config_source::digest_bytes(&value_bytes), provenance: WorkspaceProfileSourceProvenance::ProjectProfileSourceTree, editable: false, revision: state.snapshot.revision.to_string(), - size_bytes: source_entry.content.len() as u64, + size_bytes: value_bytes.len() as u64, diagnostics: Vec::new(), }); entries.insert(entry.selector.clone(), entry); @@ -198,46 +193,16 @@ pub fn project_profiles_from_workspace_config( registry_revision: format!("config:{}", state.snapshot.revision), config_revision: Some(state.snapshot.revision), tree_digest: Some(state.snapshot.digest.clone()), - projection_digest: Some(evaluation.projection_digest), + projection_digest: Some(evaluation.projection_digest.clone()), default_profile: Some(config.profile.default_profile), profiles, sources: source_summaries, diagnostics: Vec::new(), }, entries, - sources, }) } -fn evaluate_profile_source( - snapshot: &config_source::ConfigTreeSnapshot, - source_path: &VirtualPath, -) -> Result { - let contract = config_source::ToolchainContract::with_schema_bundle( - config_source::DEFAULT_SCHEMA_VERSION, - vec![source_path.clone()], - config_source::DEFAULT_IMPORT_POLICY_VERSION, - config_source::WorkspaceConfigSchemaBundle::empty(), - ); - let evaluation = config_source::SnapshotEnvironment::new(snapshot.clone()) - .evaluate_contract(&contract) - .map_err(|diagnostics| { - profile_validation_error( - "profile_source_invalid", - &serde_json::to_string(&diagnostics) - .unwrap_or_else(|_| "Profile source evaluation failed".to_string()), - ) - })?; - evaluation - .projections - .into_iter() - .next() - .map(|projection| projection.data_json) - .ok_or_else(|| { - profile_validation_error("profile_source_invalid", "Profile source has no projection") - }) -} - pub fn selector_for_workspace_candidate( projection: &ProfileConfigProjection, profile: &str, @@ -420,6 +385,16 @@ pub fn build_virtual_profile_config_bundle_with_prompt_projection( selector: &str, prompt_projection: &worker::WorkspacePromptProjection, ) -> Result> { + if projection.settings.workspace_id != workspace_id + || projection.settings.config_revision != Some(state.snapshot.revision) + || projection.settings.tree_digest.as_deref() != Some(state.snapshot.digest.as_str()) + || projection.settings.projection_digest.as_deref() + != Some(state.projection_digest.as_str()) + { + return Err(Error::Config( + "Profile projection does not match Workspace config state".into(), + )); + } validate_prompt_projection_matches_state(workspace_id, state, prompt_projection)?; let prompt_catalog = prompt_projection.catalog().clone(); let profile_selector = @@ -429,12 +404,7 @@ pub fn build_virtual_profile_config_bundle_with_prompt_projection( )) })?; let archive = match projection.entries.get(selector) { - Some(entry) => Some(build_virtual_profile_archive( - selector, - entry, - &projection.sources, - state, - )?), + Some(entry) => Some(build_virtual_profile_archive(selector, entry, state)?), None => Some(builtin_profile_source_archive(&profile_selector).map_err(Error::Store)?), }; let bundle_id = virtual_profile_bundle_id( @@ -492,19 +462,14 @@ pub(crate) fn resolve_profile_manifest_from_config_bundle( fn build_virtual_profile_archive( selector: &str, entry: &VirtualProfileEntry, - all_sources: &BTreeMap, state: &WorkspaceConfigState, ) -> Result { - let mut closure = BTreeMap::new(); - let mut imports = BTreeMap::new(); - collect_profile_import_closure(&entry.source, all_sources, &mut closure, &mut imports)?; - ProfileSourceArchive::build(ProfileSourceArchiveInput { - id: format!("workspace-config-profile-r{}", state.snapshot.revision), - entrypoints: BTreeMap::from([(selector.to_string(), entry.source.clone())]), - imports, - sources: closure, - }) - .map_err(|error| profile_validation_error("profile_source_archive_invalid", &error.to_string())) + ProfileSourceArchive::build_evaluated_profile( + format!("workspace-config-profile-r{}", state.snapshot.revision), + selector.to_string(), + entry.profile.clone(), + ) + .map_err(|error| profile_validation_error("profile_value_archive_invalid", &error.to_string())) } pub fn workspace_metadata_settings( @@ -576,124 +541,6 @@ fn profile_validation_error(code: impl Into, message: impl Into) } } -fn collect_profile_import_closure( - current_path: &str, - all_sources: &BTreeMap, - closure_sources: &mut BTreeMap, - imports: &mut BTreeMap, -) -> Result<()> { - if closure_sources.contains_key(current_path) { - return Ok(()); - } - let content = all_sources.get(current_path).ok_or_else(|| { - profile_validation_error( - "profile_source_import_missing", - &format!("Profile source import closure is missing {current_path}"), - ) - })?; - closure_sources.insert(current_path.to_string(), content.clone()); - for specifier in collect_decodal_import_specifiers(content) { - let target = resolve_profile_source_import(current_path, &specifier)?; - if !all_sources.contains_key(&target) { - return Err(profile_validation_error( - "profile_source_import_missing", - &format!( - "Profile source import {specifier:?} from {current_path} resolves to missing {target}" - ), - )); - } - imports.insert(format!("{current_path}\0{specifier}"), target.clone()); - collect_profile_import_closure(&target, all_sources, closure_sources, imports)?; - } - Ok(()) -} - -fn resolve_profile_source_import(current_path: &str, specifier: &str) -> Result { - if specifier.is_empty() || specifier.contains("://") || Path::new(specifier).is_absolute() { - return Err(profile_validation_error( - "profile_source_import_invalid", - "Profile source import must be a virtual relative path", - )); - } - let raw = specifier - .strip_prefix("project:") - .or_else(|| specifier.strip_prefix("workspace:")) - .unwrap_or(specifier); - if specifier.contains(':') && raw == specifier { - return Err(profile_validation_error( - "profile_source_import_invalid", - "Unsupported profile source import namespace", - )); - } - let base = if raw.starts_with("profiles/") || raw.starts_with("./profiles/") { - PathBuf::from(raw) - } else { - Path::new(current_path) - .parent() - .map(Path::to_path_buf) - .unwrap_or_default() - .join(raw) - }; - let normalized = normalize_virtual_profile_source_path(&base.to_string_lossy())?; - Ok(normalized) -} - -fn normalize_virtual_profile_source_path(path: &str) -> Result { - let mut normalized = PathBuf::new(); - for component in Path::new(path).components() { - match component { - Component::CurDir => {} - Component::Normal(value) => normalized.push(value), - Component::ParentDir => { - if !normalized.pop() { - return Err(profile_validation_error( - "profile_source_import_invalid", - "Profile source import escapes the virtual tree", - )); - } - } - Component::RootDir | Component::Prefix(_) => { - return Err(profile_validation_error( - "profile_source_import_invalid", - "Profile source import must be relative", - )); - } - } - } - Ok(normalized.to_string_lossy().replace('\\', "/")) -} - -fn collect_decodal_import_specifiers(content: &str) -> Vec { - let mut specifiers = Vec::new(); - for line in content.lines() { - let trimmed = line.trim_start(); - if trimmed.starts_with("//") || trimmed.starts_with('#') { - continue; - } - let Some(index) = trimmed.find("import") else { - continue; - }; - let after = trimmed[index + "import".len()..].trim_start(); - let Some(first) = after.chars().next() else { - continue; - }; - if first == '"' || first == '\'' { - if let Some(end) = after[1..].find(first) { - specifiers.push(after[1..1 + end].to_string()); - } - } else { - let ident: String = after - .chars() - .take_while(|ch| !ch.is_whitespace() && *ch != ';' && *ch != ',' && *ch != '{') - .collect(); - if !ident.is_empty() { - specifiers.push(ident); - } - } - } - specifiers -} - pub fn selector_for_builtin_candidate( id: &str, ) -> Option { @@ -711,6 +558,7 @@ pub fn selector_for_builtin_candidate( #[cfg(test)] mod tests { use super::*; + use config_source::{ConfigContentType, VirtualPath}; #[test] fn workspace_metadata_projects_server_database_record_without_filesystem_diagnostics() { @@ -779,7 +627,7 @@ mod tests { config_source::ConfigEntry::new( VirtualPath::parse("main.dcdl").unwrap(), ConfigContentType::Decodal, - r#"{ profile = { default_profile = "project:alpha"; entries = [{ selector = "project:alpha"; source = "profiles/alpha.dcdl"; label = "Alpha"; }]; }; }"#, + r#"{ profile = { default_profile = "project:alpha"; entries = [{ selector = "project:alpha"; profile = import "./profiles/alpha.dcdl"; label = "Alpha"; }]; }; }"#, ) .unwrap(), config_source::ConfigEntry::new( @@ -819,18 +667,18 @@ mod tests { .entrypoints .get("project:alpha") .map(String::as_str), - Some("profiles/alpha.dcdl") + Some("profiles/evaluated.json") ); assert_eq!(archive.reference.source_graph.source_count, 1); } #[test] - fn virtual_config_projection_preserves_import_closure() { + fn virtual_config_projection_materializes_import_closure() { let state = virtual_state(vec![ config_source::ConfigEntry::new( VirtualPath::parse("main.dcdl").unwrap(), ConfigContentType::Decodal, - r#"{ profile = { entries = [{ selector = "project:alpha"; source = "profiles/alpha.dcdl"; }]; }; }"#, + r#"{ profile = { entries = [{ selector = "project:alpha"; profile = import "./profiles/alpha.dcdl"; }]; }; }"#, ) .unwrap(), config_source::ConfigEntry::new( @@ -857,8 +705,8 @@ mod tests { .unwrap() .unwrap(); let archive = bundle.profile_source_archive.unwrap(); - assert_eq!(archive.reference.source_graph.source_count, 2); - assert_eq!(archive.reference.source_graph.import_count, 1); + assert_eq!(archive.reference.source_graph.source_count, 1); + assert_eq!(archive.reference.source_graph.import_count, 0); } #[test] @@ -955,8 +803,8 @@ mod tests { VirtualPath::parse("main.dcdl").unwrap(), ConfigContentType::Decodal, r#"{ profile = { entries = [ - { selector = "project:alpha"; source = "profiles/alpha.dcdl"; }, - { selector = "project:beta"; source = "profiles/beta.dcdl"; }, + { selector = "project:alpha"; profile = import "./profiles/alpha.dcdl"; }, + { selector = "project:beta"; profile = import "./profiles/beta.dcdl"; }, ]; }; }"#, ) .unwrap(), @@ -1002,20 +850,83 @@ mod tests { } #[test] - fn virtual_config_projection_rejects_missing_profile_source() { - let state = virtual_state(vec![ - config_source::ConfigEntry::new( - VirtualPath::parse("main.dcdl").unwrap(), - ConfigContentType::Decodal, - r#"{ profile = { entries = [{ selector = "project:alpha"; source = "profiles/missing.dcdl"; }]; }; }"#, - ) - .unwrap(), - ]); - let error = project_profiles_from_workspace_config("workspace-test", &state).unwrap_err(); - assert!( - error - .to_string() - .contains("missing from the active config revision") + fn value_profile_authoring_uses_current_provider_schema_without_inserting_defaults() { + let bundle = + config_source::WorkspaceConfigSchemaBundle::compose([ProfileConfigSchemaProvider + .contribution() + .unwrap()]) + .unwrap(); + let snapshot = config_source::ConfigTreeSnapshot::from_entries(1, [config_source::ConfigEntry::new( + VirtualPath::parse("main.dcdl").unwrap(), ConfigContentType::Decodal, + r#"{ profile = { entries = [{ selector = "project:alpha"; profile = {}; }]; }; } as WorkspaceConfigSchema"#, + ).unwrap()]).unwrap(); + let environment = config_source::SnapshotEnvironment::new(snapshot.clone()) + .with_schema_bundle(bundle.clone()); + for (body, token, label) in [ + ( + "{ profile = { entries = [{ sel }] } } as WorkspaceConfigSchema", + "sel", + "selector", + ), + ( + "{ profile = { entries = [{ pro }] } } as WorkspaceConfigSchema", + "pro", + "profile", + ), + ( + "{ profile = { entries = [{ profile = { wor } }] } } as WorkspaceConfigSchema", + "wor", + "worker", + ), + ( + "{ profile = { entries = [{ profile = { worker = { mo } } }] } } as WorkspaceConfigSchema", + "mo", + "mode", + ), + ( + "{ profile = { entries = [{ profile = { feature = { ti } } }] } } as WorkspaceConfigSchema", + "ti", + "ticket", + ), + ] { + let offset = body.rfind(token).unwrap() + token.len(); + let completion = environment + .complete_config( + &VirtualPath::parse("main.dcdl").unwrap(), + body, + offset, + true, + ) + .unwrap() + .unwrap(); + assert!( + completion.items.iter().any(|item| item.label == label), + "{label}: {completion:?}" + ); + } + for invalid in [ + r#"{ profile = { entries = [{ selector = 42; profile = {}; }]; }; } as WorkspaceConfigSchema"#, + r#"{ profile = { entries = [{ selector = "project:alpha"; profile = 42; }]; }; } as WorkspaceConfigSchema"#, + ] { + assert!( + !environment + .analyze(&VirtualPath::parse("main.dcdl").unwrap(), Some(invalid)) + .is_empty() + ); + } + let evaluation = environment + .evaluate_contract(&config_source::ToolchainContract::with_schema_bundle( + config_source::DEFAULT_SCHEMA_VERSION, + vec![VirtualPath::parse("main.dcdl").unwrap()], + config_source::DEFAULT_IMPORT_POLICY_VERSION, + bundle, + )) + .unwrap(); + assert_eq!( + evaluation.projections[0] + .data_json + .pointer("/profile/entries/0/profile"), + Some(&serde_json::json!({})) ); } } diff --git a/crates/workspace-server/src/server.rs b/crates/workspace-server/src/server.rs index 84fb046e1..ac8759821 100644 --- a/crates/workspace-server/src/server.rs +++ b/crates/workspace-server/src/server.rs @@ -12320,6 +12320,7 @@ fn config_schema_bundle_to_api( namespace: contribution.namespace, version: contribution.version, source: contribution.source, + authoring_source: contribution.authoring_source, projection_validator: contribution .projection_validator .map(config_projection_validator_to_api), @@ -33466,6 +33467,7 @@ impl IntoResponse for ApiError { #[cfg(test)] mod tests { mod subjektiv_jobs_tests; + mod value_profiles_tests; mod worker_operations_tests; include!("server_workspace_config_tests.rs"); use super::*; diff --git a/crates/workspace-server/src/server/tests/subjektiv_jobs_tests.rs b/crates/workspace-server/src/server/tests/subjektiv_jobs_tests.rs index 78c191a4d..6905bfe58 100644 --- a/crates/workspace-server/src/server/tests/subjektiv_jobs_tests.rs +++ b/crates/workspace-server/src/server/tests/subjektiv_jobs_tests.rs @@ -454,7 +454,7 @@ async fn backend_job_project_recipe_is_resolved_and_delivered_without_system_ove entrypoints: state.contract.entrypoints.iter().map(|p| p.as_str().into()).collect(), changes: vec![server_api::ConfigTreeChange::Update { path: entrypoint.as_str().into(), expected_digest: root.content_digest.clone(), - content: "{ profile = { entries = [{ selector = \"project:job-recipe\"; source = \"profiles/job-recipe.dcdl\"; }]; }; }".into(), + content: "{ profile = { entries = [{ selector = \"project:job-recipe\"; profile = import \"./profiles/job-recipe.dcdl\"; }]; }; }".into(), }, server_api::ConfigTreeChange::Create { path: "profiles/job-recipe.dcdl".into(), content_type: server_api::ConfigContentType::Decodal, content: "{ slug = \"job-recipe\"; scope = \"workspace_read\"; model = { id = \"fixture-model\"; }; engine = { instruction = \"role.default\"; }; feature = { task = { enabled = true; }; }; }".into(), diff --git a/crates/workspace-server/src/server/tests/value_profiles_tests.rs b/crates/workspace-server/src/server/tests/value_profiles_tests.rs new file mode 100644 index 000000000..984f8f5b4 --- /dev/null +++ b/crates/workspace-server/src/server/tests/value_profiles_tests.rs @@ -0,0 +1,362 @@ +use super::*; +use crate::profile_settings::{ + build_virtual_profile_config_bundle, project_profiles_from_workspace_config, +}; + +const PROFILE: &str = r#"{ + slug = "alpha"; + worker = { mode = "wip"; }; + model = { ref = "codex-oauth/gpt-5.6-sol"; }; + feature = { task = { enabled = true; }; ticket = { enabled = false; }; }; +}"#; + +fn request( + api: &WorkspaceApi, + source: &str, + extra: Vec, +) -> ConfigCommitRequest { + let state = api + .config_store + .load_workspace_config(TEST_WORKSPACE_ID) + .unwrap() + .unwrap(); + let main = state + .snapshot + .get(&config_source::VirtualPath::parse("main.dcdl").unwrap()) + .unwrap(); + let mut changes = vec![config_source::ConfigTreeChange::Update { + path: main.path.clone(), + expected_digest: main.content_digest.clone(), + content: source.into(), + }]; + changes.extend(extra); + ConfigCommitRequest { + base_revision: state.snapshot.revision, + base_digest: state.snapshot.digest, + entrypoints: state.contract.entrypoints, + changes, + } +} + +fn source(value: &str) -> String { + format!( + r#"{{ profile = {{ default_profile = "project:alpha"; entries = [{{ selector = "project:alpha"; label = "Alpha"; description = "Value recipe"; profile = {value}; }}]; }}; }}"# + ) +} + +#[tokio::test] +async fn value_profiles_save_project_and_runtime_consume_the_same_revision() { + let dir = tempfile::tempdir().unwrap(); + let api = test_api(dir.path()).await; + let forms = [ + PROFILE.to_string(), + r#"import "./recipes/alpha.dcdl""#.into(), + r#"(import "./recipes/base.dcdl") // { worker = { mode = "wip"; }; feature.task.enabled = true; }"#.into(), + ]; + let mut manifests = Vec::new(); + let mut saved_manifest = None; + for (index, form) in forms.iter().enumerate() { + let extra = if index == 0 { + vec![ + config_source::ConfigTreeChange::Create { + path: config_source::VirtualPath::parse("recipes/alpha.dcdl").unwrap(), + content_type: config_source::ConfigContentType::Decodal, + content: PROFILE.into(), + }, + config_source::ConfigTreeChange::Create { + path: config_source::VirtualPath::parse("recipes/base.dcdl").unwrap(), + content_type: config_source::ConfigContentType::Decodal, + content: PROFILE + .replace("wip", "tools") + .replace("enabled = true", "enabled = false"), + }, + ] + } else { + vec![] + }; + let state = commit_workspace_config_tree( + &api, + TEST_WORKSPACE_ID, + &request(&api, &source(form), extra), + ) + .unwrap(); + let loaded = api + .config_store + .load_workspace_config(TEST_WORKSPACE_ID) + .unwrap() + .unwrap(); + assert_eq!(loaded, state); + // The Browser receives the same fingerprint-bound authoring metadata through REST. + let wire = workspace_config_state_to_api(loaded.clone()); + let decoded: config_source::WorkspaceConfigSchemaBundle = + serde_json::from_value(serde_json::to_value(wire.contract.schema_bundle).unwrap()) + .unwrap(); + decoded.validate().unwrap(); + assert_eq!(decoded, loaded.contract.schema_bundle); + assert!( + decoded + .contributions + .iter() + .find(|entry| entry.provider_id == "builtin:profile") + .unwrap() + .authoring_source + .is_some() + ); + let projection = + project_profiles_from_workspace_config(TEST_WORKSPACE_ID, &loaded).unwrap(); + assert_eq!( + projection.settings.default_profile.as_deref(), + Some("project:alpha") + ); + assert_eq!( + projection.settings.config_revision, + Some(state.snapshot.revision) + ); + let selected = projection + .settings + .profiles + .iter() + .find(|entry| entry.selector == "project:alpha") + .unwrap(); + assert_eq!(selected.label, "Alpha"); + assert_eq!(selected.description.as_deref(), Some("Value recipe")); + assert!(selected.is_default); + assert_eq!(selected.profile_source_id.as_deref(), Some("project:alpha")); + let bundle = build_virtual_profile_config_bundle( + &projection, + &state, + TEST_WORKSPACE_ID, + "2026-01-01T00:00:00Z", + "project:alpha", + ) + .unwrap() + .unwrap(); + assert_eq!(bundle.metadata.digest, bundle.computed_digest()); + assert_eq!( + bundle.metadata.revision, + state.snapshot.revision.to_string() + ); + let archive = bundle.profile_source_archive.as_ref().unwrap(); + let verified = archive.verify().unwrap(); + // This is the Runtime's archive consumer. It needs neither the Workspace tree nor imports. + let resolved = verified + .resolve_profile( + "project:alpha", + Path::new("/runtime-worker"), + "value-worker", + ) + .unwrap(); + assert_eq!(resolved.worker.mode, manifest::WorkerMode::Wip); + assert!(resolved.feature.task.enabled); + assert!(!resolved.feature.ticket.enabled); + assert!(!resolved.feature.ticket.authoring); + assert!(!resolved.feature.sub_worker.enabled); + assert_eq!(archive.reference.source_graph.import_count, 0); + let evaluation = config_source::SnapshotEnvironment::new(state.snapshot.clone()) + .evaluate_contract(&state.contract) + .unwrap(); + let value = evaluation.projections[0] + .data_json + .pointer("/profile/entries/0/profile") + .unwrap(); + assert!(value.is_object()); + assert!( + value.get("engine").is_none(), + "omission must remain omission in the Profile value" + ); + let mut snapshot = serde_json::to_value(&resolved).unwrap(); + snapshot.as_object_mut().unwrap().remove("profile"); // revision-specific provenance only + manifests.push(snapshot); + if index == 0 { + saved_manifest = + Some(manifest::write_persisted_worker_manifest_snapshot(&resolved).unwrap()); + } + if index == 2 { + let mut other_state = state.clone(); + other_state.snapshot.revision += 1; + assert!( + build_virtual_profile_config_bundle( + &projection, + &other_state, + TEST_WORKSPACE_ID, + "created", + "project:alpha" + ) + .unwrap_err() + .to_string() + .contains("does not match") + ); + } + } + assert_eq!(manifests[0], manifests[1]); + assert_eq!(manifests[1], manifests[2]); + // Saving a new recipe is not an operation on existing Workers or their persisted Manifest. + let state = commit_workspace_config_tree( + &api, + TEST_WORKSPACE_ID, + &request( + &api, + &source( + &PROFILE + .replace("wip", "tools") + .replace("enabled = true", "enabled = false"), + ), + vec![], + ), + ) + .unwrap(); + let projection = project_profiles_from_workspace_config(TEST_WORKSPACE_ID, &state).unwrap(); + let bundle = build_virtual_profile_config_bundle( + &projection, + &state, + TEST_WORKSPACE_ID, + "created", + "project:alpha", + ) + .unwrap() + .unwrap(); + let fresh = crate::profile_settings::resolve_profile_manifest_from_config_bundle( + &bundle, + "project:alpha", + ) + .unwrap(); + assert_eq!(fresh.worker.mode, manifest::WorkerMode::Tools); + assert!(!fresh.feature.task.enabled); + let restored = + manifest::read_persisted_worker_manifest_snapshot(saved_manifest.unwrap()).unwrap(); + assert_eq!(restored.worker.mode, manifest::WorkerMode::Wip); + assert!(restored.feature.task.enabled); +} + +#[tokio::test] +async fn value_profiles_invalid_saves_preserve_the_active_config() { + let dir = tempfile::tempdir().unwrap(); + let api = test_api(dir.path()).await; + let before = commit_workspace_config_tree( + &api, + TEST_WORKSPACE_ID, + &request(&api, &source(PROFILE), vec![]), + ) + .unwrap(); + let invalid = [ + (source("42"), ""), + (source(r#"{ worker = { mode = "not-a-mode"; }; }"#), "profile_value_invalid"), + (source(r#"{ worker = { name = "runtime-only"; }; }"#), "profile_value_invalid"), + (source(r#"import "./missing.dcdl""#), ""), + (source(r#"import "../outside.dcdl""#), ""), + (r#"{ profile = { entries = [{ selector = "project:alpha"; profile = {}; }, { selector = "project:alpha"; profile = {}; }]; }; }"#.into(), "profile_selector_duplicate"), + (r#"{ profile = { default_profile = "project:unknown"; }; }"#.into(), "unknown_default_profile"), + (r#"{ profile = { entries = [{ selector = "project:"; profile = {}; }]; }; }"#.into(), "profile_selector_invalid"), + (r#"{ profile = { entries = [{ selector = "project:alpha"; source = "profiles/alpha.dcdl"; }]; }; }"#.into(), ""), + ]; + for (source, code) in invalid { + let error = + commit_workspace_config_tree(&api, TEST_WORKSPACE_ID, &request(&api, &source, vec![])) + .unwrap_err(); + assert!(error.to_string().contains(code), "{error}"); + assert_eq!( + api.config_store + .load_workspace_config(TEST_WORKSPACE_ID) + .unwrap() + .unwrap(), + before + ); + } +} + +#[tokio::test] +async fn value_profiles_legacy_source_config_requires_explicit_lossless_migration() { + let dir = tempfile::tempdir().unwrap(); + let api = test_api(dir.path()).await; + let mut contributions = api.config_schema_registry.compose().unwrap().contributions; + let profile_schema = contributions + .iter_mut() + .find(|entry| entry.provider_id == "builtin:profile") + .unwrap(); + *profile_schema = config_source::ConfigSchemaContribution::new("builtin:profile", "profile", "1", r#"{ + profile = { default_profile = String default "builtin:companion"; + entries = [...{ selector = String; source = String; label = String default ""; description = String default ""; }] default []; + }; + }"#).unwrap(); + let old_schema = config_source::WorkspaceConfigSchemaBundle::compose(contributions).unwrap(); + let old_source = r#"{ profile = { default_profile = "project:alpha"; entries = [{ selector = "project:alpha"; label = "Alpha"; source = "recipes/alpha.dcdl"; }]; }; }"#; + let candidate = api + .config_store + .evaluate_workspace_config_candidate_with_schema( + TEST_WORKSPACE_ID, + &request( + &api, + old_source, + vec![config_source::ConfigTreeChange::Create { + path: config_source::VirtualPath::parse("recipes/alpha.dcdl").unwrap(), + content_type: config_source::ConfigContentType::Decodal, + content: PROFILE.into(), + }], + ), + old_schema, + ) + .unwrap(); + // Fixture simulates a previously persisted v1 schema/revision. + let legacy = api + .config_store + .commit_evaluated_workspace_config(TEST_WORKSPACE_ID, &candidate) + .unwrap(); + let error = project_profiles_from_workspace_config(TEST_WORKSPACE_ID, &legacy).unwrap_err(); + assert!( + error + .to_string() + .contains("profile_source_registration_removed") + ); + assert!(error.to_string().contains("profile = import")); + assert_eq!( + api.config_store + .load_workspace_config(TEST_WORKSPACE_ID) + .unwrap() + .unwrap(), + legacy + ); + assert!( + commit_workspace_config_tree(&api, TEST_WORKSPACE_ID, &request(&api, old_source, vec![])) + .is_err() + ); + assert_eq!( + api.config_store + .load_workspace_config(TEST_WORKSPACE_ID) + .unwrap() + .unwrap(), + legacy + ); + let migrated_source = old_source.replace( + r#"source = "recipes/alpha.dcdl""#, + r#"profile = import "./recipes/alpha.dcdl""#, + ); + let migrated = commit_workspace_config_tree( + &api, + TEST_WORKSPACE_ID, + &request(&api, &migrated_source, vec![]), + ) + .unwrap(); + let projection = project_profiles_from_workspace_config(TEST_WORKSPACE_ID, &migrated).unwrap(); + assert_eq!( + projection.settings.default_profile.as_deref(), + Some("project:alpha") + ); + assert_eq!( + migrated + .snapshot + .get(&config_source::VirtualPath::parse("recipes/alpha.dcdl").unwrap()), + legacy + .snapshot + .get(&config_source::VirtualPath::parse("recipes/alpha.dcdl").unwrap()) + ); + assert_eq!( + projection + .settings + .profiles + .iter() + .find(|entry| entry.selector == "project:alpha") + .unwrap() + .label, + "Alpha" + ); +} diff --git a/docs/design/profiles-manifests-prompts.md b/docs/design/profiles-manifests-prompts.md index 4e98f622a..8d5192f39 100644 --- a/docs/design/profiles-manifests-prompts.md +++ b/docs/design/profiles-manifests-prompts.md @@ -17,7 +17,33 @@ A Profile should not contain runtime-bound fields: Those fields depend on one run, one parent, or one machine. Putting them in a reusable Profile makes reuse unsafe. -Yoi Profiles are data artifacts resolved from builtin profile definitions, `profiles.toml`, Decodal source archives, or explicit JSON/TOML artifacts. Decodal is the authoring syntax used by the Workspace profile editor and Backend Runtime archive path; JSON/TOML artifacts are the low-level resolver interchange format. Runtime launch should not depend on executable profile scripts. +Yoi Profiles are data artifacts resolved from builtin profile definitions, `profiles.toml`, Workspace Config values, or explicit JSON/TOML artifacts. Decodal is the Workspace authoring syntax; JSON/TOML artifacts are the low-level resolver interchange format. Runtime launch does not depend on executable profile scripts. + +### Workspace registration and migration + +Register the Profile **value**, not a source pathname: + +```dcdl +{ + profile = { + default_profile = "project:my-companion"; + entries = [{ + selector = "project:my-companion"; + label = "My Companion"; + description = "My reusable Worker recipe"; + profile = import "./profiles/my-companion.dcdl"; + }]; + }; +} as WorkspaceConfigSchema +``` + +The imported file can contain `{ worker = { mode = "wip"; }; model = { ref = "codex-oauth/gpt-5.6-sol"; }; feature = { task = { enabled = true; }; }; }`. That record can also be written directly at `entries[0].profile`. Composition uses ordinary Decodal expressions, for example `(import "./profiles/base.dcdl") // { worker = { mode = "wip"; }; }` for an explicit patch, or `&` for compatible refinement. No dedicated Profile file or `profiles/` directory is required. Imports are relative to the **containing virtual config file**, not a host filesystem path; missing imports and virtual-tree escapes are rejected. + +`selector` must be a nonempty `project:*` selector, unique in the Workspace. `label` and `description` are optional display metadata. An omitted `default_profile` selects `builtin:companion`; an explicitly unknown default is an error, not a fallback. A project Profile is a partial recipe resolved against `WorkerManifestConfig::resolution_defaults()`, **not** implicitly inherited from a builtin role. Explicit values remain explicit and omitted Profile fields remain absent in the transported value. Builtin-value import helpers are not part of this registration contract. + +The former `entries = [{ selector = "project:name"; source = "profiles/name.dcdl"; }]` registration is no longer accepted. Migrate it explicitly to `profile = import "./profiles/name.dcdl";`, preserving the selector, label, description and default. For registrations in a nested config file, adjust the relative import to the original virtual-tree entry (for example `../profiles/name.dcdl`). Do not rename or recreate the Profile file merely for registration. Previously saved source-based revisions remain readable as config data and are not rewritten, deleted, or silently substituted with a builtin. Their Profile projection/launch reports `profile_source_registration_removed` with the replacement form; saves under the new schema reject the old field. Existing Workers continue using their saved Manifest while the author migrates and saves the config. + +The schema contribution separates its materialized registration schema from an optional, fingerprint-bound `authoring_source`. The latter supplies editor field suggestions inside array elements and partial Profile records; it is never evaluated as defaults or substituted for the validation schema. Decodal structural diagnostics cover registration/value shape, and the shared Backend save boundary checks full Profile/Manifest semantics (including mode, forbidden runtime fields, duplicate selectors and default references). UI and WIP saves use that same boundary; invalid candidates leave the active config revision untouched. ## Manifests @@ -27,7 +53,7 @@ Source/partial layers may omit fields. Resolved manifests should be explicit eno `--manifest ` exists as an explicit low-level escape hatch. Normal fresh startup selects a `builtin:*` or `project:*` Profile from the Backend-managed Workspace Config revision rather than applying an ambient manifest cascade. -Project Profiles are evaluated from the revisioned Virtual Config's Decodal source/import closure. The Backend packages that closure into a digest-bound Profile source archive, delivers it with the resolved launch bundle, and the Worker persists the resulting Manifest for restore. Files below the Workdir are not implicit Profile override layers. +Project Profiles are evaluated as part of the revisioned Virtual Config, including its imports and value composition. The Backend packages the **evaluated selected value** into a digest-bound JSON entry in the existing Profile archive transport, and binds the launch bundle to the Workspace identity, revision, tree/projection digests and schema/toolchain fingerprints. Runtime verifies the archive and resolves that exact value without re-evaluating Decodal, scanning imports or reading Workspace files. Builtin Profiles retain their embedded Decodal archive path. Saving config changes only future fresh launches; the Worker persists the resulting resolved Manifest and restore uses that saved snapshot rather than selecting the current recipe again. Files below the Workdir are not implicit Profile override layers. ## Local stdio MCP server declarations diff --git a/openapi/server-api.json b/openapi/server-api.json index c217d3c0f..9eb8e17d3 100644 --- a/openapi/server-api.json +++ b/openapi/server-api.json @@ -1235,6 +1235,13 @@ "ConfigSchemaContribution": { "additionalProperties": false, "properties": { + "authoring_source": { + "description": "Completion-only shape for partial values; never materialized as defaults.", + "type": [ + "string", + "null" + ] + }, "namespace": { "type": "string" }, @@ -15474,7 +15481,7 @@ "info": { "title": "Yoi Server API", "version": "0.1.0", - "x-yoi-source-digest": "sha256:fd06f382c6d33a5c3cc98ef9e264545923c53fa95a9be555a85680f98c6065da" + "x-yoi-source-digest": "sha256:a6a7147c9a2f465a5da044e9ba21947cb3d86eacbfe3905696483917e794d5cf" }, "openapi": "3.1.0", "paths": { diff --git a/resources/config-schema/profile-authoring.dcdl b/resources/config-schema/profile-authoring.dcdl new file mode 100644 index 000000000..62317038e --- /dev/null +++ b/resources/config-schema/profile-authoring.dcdl @@ -0,0 +1,72 @@ +# Completion-only shape of partial Profile values. This is never materialized or +# used as defaults: omitted fields remain omitted until Manifest resolution. +let + Flag = { enabled = Bool; }; + Model = { + ref = String; scheme = String; base_url = String; model_id = String; + auth = { kind = String; ref = String; file = String; }; + capability = Unknown; context_window = Int; max_context_window = Int; + }; + Extraction = { + enabled = Bool; model = Model; reasoning = String; + threshold = Int; worker_max_turns = Int; + }; + Scope = { intent = String; deny_write = [...String]; symlink_policy = String; }; + Profile = { + slug = String; + description = String; + worker = { mode = String; }; + model = Model; + engine = { + instruction = String; language = String; reasoning = Unknown; + max_tokens = Int; max_turns = Int; temperature = Unknown; top_p = Unknown; + top_k = Int; stop_sequences = [...String]; tool_call_dispatch = String; + tool_output = { default_max_bytes = Int; per_tool = { ...Int }; }; + file_upload = { max_bytes = Int; }; + }; + scope = Scope; + delegation_scope = Scope; + session = { + record_event_trace = Bool; + }; + permissions = { default_action = String; rule = [...{ tool = String; pattern = String; action = String; }]; }; + feature = { + task = Flag; web = Flag; image = Flag; sub_worker = Flag; flow = Flag; + worker = { enabled = Bool; direct_spawn = Bool; }; + workspace_worker_discovery = Flag; objective = Flag; manage_workdir = Flag; + workdir_catalog = Flag; workspace_config = Flag; orchestration = Flag; + ticket = { enabled = Bool; authoring = Bool; thread = Bool; intake = Bool; workflow = Bool; }; + merge_request = { show = Bool; open = Bool; review = Bool; readiness_check = Bool; complete = Bool; }; + memory = { + enabled = Bool; staging_tools = Bool; + resident = { inject_summary = Bool; }; + extraction = Extraction; + consolidation = { request_enabled = Bool; }; + }; + subjektiv = { enabled = Bool; consolidation_tools = Bool; extraction = Extraction; }; + }; + mcp = { stdio_server = [...{ + name = String; command = String; args = [...String]; + cwd = { kind = String; path = String; }; + env = { inherit = [...String]; set = { ...Unknown }; }; + }]; }; + compaction = { + kind = String; threshold = Unknown; request_threshold = Unknown; + prune_enabled = Bool; worker_context_max_tokens = Unknown; + worker_max_turns = Int; model = Model; + }; + web = { + enabled = Bool; allow_private_addresses = Bool; + search = { enabled = Bool; provider = String; api_key_secret = String; timeout_secs = Int; base_url = String; country = String; search_lang = String; ui_lang = String; safesearch = String; }; + fetch = { enabled = Bool; timeout_secs = Int; redirect_limit = Int; max_response_bytes = Int; max_output_bytes = Int; allow_private_addresses = Bool; }; + }; + skills = { directories = [...String]; }; + }; +in { + profile = { + default_profile = String; + entries = [...{ + selector = String; profile = Profile; label = String; description = String; + }]; + }; +} diff --git a/resources/config-schema/profile.dcdl b/resources/config-schema/profile.dcdl new file mode 100644 index 000000000..aff4ccadc --- /dev/null +++ b/resources/config-schema/profile.dcdl @@ -0,0 +1,11 @@ +{ + profile = { + default_profile = String default "builtin:companion"; + entries = [...{ + selector = String; + profile = { ...Unknown }; + label = String default ""; + description = String default ""; + }] default []; + }; +} diff --git a/web/workspace/deno.json b/web/workspace/deno.json index 9479ef44f..e17a7fb8b 100644 --- a/web/workspace/deno.json +++ b/web/workspace/deno.json @@ -6,7 +6,7 @@ "dev": "deno run -A npm:vite@8.3.2 dev", "dev:backend": "cd ../.. && cargo run -p yoi-workspace-server --bin yoi-server -- serve --listen 127.0.0.1:8787", "check": "deno run -A npm:@sveltejs/kit@3.0.0 sync && deno run -A npm:svelte-check@4.7.6 --tsconfig ./tsconfig.json", - "test": "deno test --allow-read=src,test,tests,../../docs --allow-env=LOG,VSCODE_TEXTMATE_DEBUG,NODE_ENV tests/workspace-model.test.ts tests/repository-api.test.ts tests/workspace-catalog.test.ts tests/profile-api.test.ts tests/skill-api.test.ts tests/tooltip-contract.test.ts tests/bevel-contract.test.ts tests/bevel-line-contract.test.ts tests/typography-contract.test.ts src/lib/workspace/auth/model.test.ts src/lib/workspace/protocol-validator.test.ts tests/auth-api.test.ts src/lib/workspace/api/http.test.ts src/lib/workspace/api/workers.test.ts src/lib/workspace/api/ticket-browser.test.ts src/lib/workspace/header/breadcrumb-model.test.ts src/lib/workspace/console/chat-submit.test.ts src/lib/workspace/console/composer-delivery.test.ts test/composer-history.test.ts tests/composer-paste.test.ts src/lib/workspace/console/composer-command.test.ts src/lib/workspace/console/composer-draft.test.ts src/lib/workspace/console/composer-completion.test.ts src/lib/workspace/console/composer-invocation.test.ts src/lib/workspace/console/file-completions.test.ts test/console/ansi.test.ts src/lib/workspace/console/history.test.ts src/lib/workspace/console/model.test.ts src/lib/workspace/console/turn-navigation.test.ts src/lib/workspace/console/run-status.test.ts src/lib/workspace/companion/api.test.ts tests/workdir-api.test.ts tests/workdir-permissions.test.ts src/lib/workspace/console/tasks.test.ts test/ticket-detail-route-reuse.test.ts test/spa-shell.test.ts test/objective-pages.test.ts test/repositories/ui.test.ts src/lib/workspace/console/worker-console.ui.test.ts src/lib/workspace/settings/model.test.ts tests/runtime-connection.test.ts tests/runtime-management.test.ts tests/runtime-management-source.test.ts src/lib/workspace/sidebar/override-stack.test.ts src/lib/workspace/sidebar/route-ownership.test.ts src/lib/workspace/sidebar/workers.test.ts src/lib/workspace/sidebar/workspace-switcher.test.ts src/lib/workspace/sidebar/worker-subscription.test.ts src/lib/workspace/sidebar/worker-workdir-meta.test.ts src/lib/workspace/sidebar/worker-launch.test.ts tests/runtime-workers.test.ts test/sidebar/worker-actions.test.ts src/lib/workspace/tickets/merge-request-resources.test.ts src/lib/workspace/tickets/ticket-panel.test.ts test/merge-request-status.test.ts test/config-source/decodal-grammar.test.ts test/config-source/editor-state.test.ts test/config-source/fixed-schema-wrapper.test.ts test/config-source/toolchain.test.ts test/config-source/wasm-parity.test.ts test/config-source/api.test.ts tests/memory-api.test.ts test/repository-access/api.test.ts test/repository-access/loader.test.ts test/repository-access/model.test.ts test/repository-access/structure.test.ts test/repository-ssh-connection-ui.test.ts", + "test": "deno test --allow-read=src,test,tests,../../docs,../../resources/config-schema --allow-env=LOG,VSCODE_TEXTMATE_DEBUG,NODE_ENV tests/workspace-model.test.ts tests/repository-api.test.ts tests/workspace-catalog.test.ts tests/profile-api.test.ts tests/skill-api.test.ts tests/tooltip-contract.test.ts tests/bevel-contract.test.ts tests/bevel-line-contract.test.ts tests/typography-contract.test.ts src/lib/workspace/auth/model.test.ts src/lib/workspace/protocol-validator.test.ts tests/auth-api.test.ts src/lib/workspace/api/http.test.ts src/lib/workspace/api/workers.test.ts src/lib/workspace/api/ticket-browser.test.ts src/lib/workspace/header/breadcrumb-model.test.ts src/lib/workspace/console/chat-submit.test.ts src/lib/workspace/console/composer-delivery.test.ts test/composer-history.test.ts tests/composer-paste.test.ts src/lib/workspace/console/composer-command.test.ts src/lib/workspace/console/composer-draft.test.ts src/lib/workspace/console/composer-completion.test.ts src/lib/workspace/console/composer-invocation.test.ts src/lib/workspace/console/file-completions.test.ts test/console/ansi.test.ts src/lib/workspace/console/history.test.ts src/lib/workspace/console/model.test.ts src/lib/workspace/console/turn-navigation.test.ts src/lib/workspace/console/run-status.test.ts src/lib/workspace/companion/api.test.ts tests/workdir-api.test.ts tests/workdir-permissions.test.ts src/lib/workspace/console/tasks.test.ts test/ticket-detail-route-reuse.test.ts test/spa-shell.test.ts test/objective-pages.test.ts test/repositories/ui.test.ts src/lib/workspace/console/worker-console.ui.test.ts src/lib/workspace/settings/model.test.ts tests/runtime-connection.test.ts tests/runtime-management.test.ts tests/runtime-management-source.test.ts src/lib/workspace/sidebar/override-stack.test.ts src/lib/workspace/sidebar/route-ownership.test.ts src/lib/workspace/sidebar/workers.test.ts src/lib/workspace/sidebar/workspace-switcher.test.ts src/lib/workspace/sidebar/worker-subscription.test.ts src/lib/workspace/sidebar/worker-workdir-meta.test.ts src/lib/workspace/sidebar/worker-launch.test.ts tests/runtime-workers.test.ts test/sidebar/worker-actions.test.ts src/lib/workspace/tickets/merge-request-resources.test.ts src/lib/workspace/tickets/ticket-panel.test.ts test/merge-request-status.test.ts test/config-source/decodal-grammar.test.ts test/config-source/editor-state.test.ts test/config-source/fixed-schema-wrapper.test.ts test/config-source/toolchain.test.ts test/config-source/wasm-parity.test.ts test/config-source/api.test.ts tests/memory-api.test.ts test/repository-access/api.test.ts test/repository-access/loader.test.ts test/repository-access/model.test.ts test/repository-access/structure.test.ts test/repository-ssh-connection-ui.test.ts", "test:component": "deno run -A npm:vitest@5.0.3 run --config vitest.config.ts", "build": "deno run -A npm:vite@8.3.2 build", "preview": "deno run -A npm:vite@8.3.2 preview", diff --git a/web/workspace/src/lib/generated/companion-api.ts b/web/workspace/src/lib/generated/companion-api.ts index 8a530c53d..f85678a77 100644 --- a/web/workspace/src/lib/generated/companion-api.ts +++ b/web/workspace/src/lib/generated/companion-api.ts @@ -1,6 +1,6 @@ // @generated by yoi-companion-openapi-typescript@1. Do not edit. // Input: openapi/server-api.json -// Input contract: 0.1.0 (sha256:fd06f382c6d33a5c3cc98ef9e264545923c53fa95a9be555a85680f98c6065da) +// Input contract: 0.1.0 (sha256:a6a7147c9a2f465a5da044e9ba21947cb3d86eacbfe3905696483917e794d5cf) // Options: companion-operation-schema-closure,openapi-3.1,strict-integer-ranges,sorted-output // Output: web/workspace/src/lib/generated/companion-api.ts // Regenerate/check: cargo run -q -p server-api --example generate_companion_api_types -- --check diff --git a/web/workspace/src/lib/generated/legacy-server-api.ts b/web/workspace/src/lib/generated/legacy-server-api.ts index 7a34b2e60..aeb99cdaf 100644 --- a/web/workspace/src/lib/generated/legacy-server-api.ts +++ b/web/workspace/src/lib/generated/legacy-server-api.ts @@ -237,6 +237,10 @@ export type ConfigSchemaContribution = { version: string; source: string; projection_validator?: ConfigProjectionValidator; + /** + * Completion-only shape for partial values; never materialized as defaults. + */ + authoring_source?: string; source_digest: string; }; diff --git a/web/workspace/src/lib/generated/repository-api.ts b/web/workspace/src/lib/generated/repository-api.ts index 5b72d2098..2ac059cfb 100644 --- a/web/workspace/src/lib/generated/repository-api.ts +++ b/web/workspace/src/lib/generated/repository-api.ts @@ -1,6 +1,6 @@ // @generated by yoi-repository-openapi-typescript@1. Do not edit. // Input: openapi/server-api.json -// Input contract: 0.1.0 (sha256:fd06f382c6d33a5c3cc98ef9e264545923c53fa95a9be555a85680f98c6065da) +// Input contract: 0.1.0 (sha256:a6a7147c9a2f465a5da044e9ba21947cb3d86eacbfe3905696483917e794d5cf) // Options: repository-operation-schema-closure,openapi-3.1,format:uint64=safe-number,strict-safe-integers,sorted-output // Output: web/workspace/src/lib/generated/repository-api.ts // Regenerate/check: cargo run -q -p server-api --example generate_repository_openapi_types -- --check diff --git a/web/workspace/src/lib/generated/runtime-api.ts b/web/workspace/src/lib/generated/runtime-api.ts index 53eeae412..9197abbc9 100644 --- a/web/workspace/src/lib/generated/runtime-api.ts +++ b/web/workspace/src/lib/generated/runtime-api.ts @@ -1,6 +1,6 @@ // @generated by yoi-runtime-openapi-typescript@1. Do not edit. // Input: openapi/server-api.json -// Input contract: 0.1.0 (sha256:fd06f382c6d33a5c3cc98ef9e264545923c53fa95a9be555a85680f98c6065da) +// Input contract: 0.1.0 (sha256:a6a7147c9a2f465a5da044e9ba21947cb3d86eacbfe3905696483917e794d5cf) // Options: runtime-operation-schema-closure,openapi-3.1,strict-integer-ranges,sorted-output // Output: web/workspace/src/lib/generated/runtime-api.ts // Regenerate/check: cargo run -q -p server-api --example generate_runtime_api_types -- --check diff --git a/web/workspace/src/lib/generated/ticket-api.ts b/web/workspace/src/lib/generated/ticket-api.ts index 657aa7d1b..530b8fbe0 100644 --- a/web/workspace/src/lib/generated/ticket-api.ts +++ b/web/workspace/src/lib/generated/ticket-api.ts @@ -1,6 +1,6 @@ // @generated by yoi-ticket-browser-openapi-typescript@1. Do not edit. // Input: openapi/server-api.json -// Input contract: 0.1.0 (sha256:fd06f382c6d33a5c3cc98ef9e264545923c53fa95a9be555a85680f98c6065da) +// Input contract: 0.1.0 (sha256:a6a7147c9a2f465a5da044e9ba21947cb3d86eacbfe3905696483917e794d5cf) // Options: ticket-objective-merge-request-browser-operation-schema-closure,openapi-3.1,strict-integer-ranges,sorted-output // Output: web/workspace/src/lib/generated/ticket-api.ts // Regenerate/check: cargo run -q -p server-api --example generate_ticket_api_types -- --check diff --git a/web/workspace/src/lib/generated/worker-launch-api.ts b/web/workspace/src/lib/generated/worker-launch-api.ts index f56aba174..2ec93ec9e 100644 --- a/web/workspace/src/lib/generated/worker-launch-api.ts +++ b/web/workspace/src/lib/generated/worker-launch-api.ts @@ -1,6 +1,6 @@ // @generated by yoi-worker-openapi-typescript@1. Do not edit. // Input: openapi/server-api.json -// Input contract: 0.1.0 (sha256:fd06f382c6d33a5c3cc98ef9e264545923c53fa95a9be555a85680f98c6065da) +// Input contract: 0.1.0 (sha256:a6a7147c9a2f465a5da044e9ba21947cb3d86eacbfe3905696483917e794d5cf) // Options: worker-operation-schema-closure,openapi-3.1,strict-integer-ranges,sorted-output // Output: web/workspace/src/lib/generated/worker-launch-api.ts // Regenerate/check: cargo run -q -p server-api --example generate_worker_launch_api_types -- --check diff --git a/web/workspace/src/lib/workspace/config-source/api.ts b/web/workspace/src/lib/workspace/config-source/api.ts index c277ccc5d..2afb76407 100644 --- a/web/workspace/src/lib/workspace/config-source/api.ts +++ b/web/workspace/src/lib/workspace/config-source/api.ts @@ -187,7 +187,7 @@ function parseContribution(value: unknown): ConfigSchemaContribution { const item = record( value, ["provider_id", "namespace", "version", "source", "source_digest"], - ["projection_validator"], + ["projection_validator", "authoring_source"], ); const projection = item.projection_validator === undefined ? undefined @@ -197,6 +197,12 @@ function parseContribution(value: unknown): ConfigSchemaContribution { namespace: boundedString(item.namespace), version: boundedString(item.version), source: boundedString(item.source, MAX_SCHEMA_SOURCE_BYTES), + ...(item.authoring_source === undefined ? {} : { + authoring_source: boundedString( + item.authoring_source, + MAX_SCHEMA_SOURCE_BYTES, + ), + }), ...(projection === undefined ? {} : { projection_validator: projection }), source_digest: boundedString(item.source_digest, MAX_DIGEST_BYTES), }; diff --git a/web/workspace/src/lib/workspace/config-source/generated/config_source_wasm_bg.wasm b/web/workspace/src/lib/workspace/config-source/generated/config_source_wasm_bg.wasm index 4662c4ac37451a58907c03aa11860e19860922fa..8fc0b42457573bdb91793220a34f0aaabd88b0b1 100644 GIT binary patch delta 299942 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 delta 282766 zcmce92YeJ&*Z1DLZDw|pY)CJ_?9vhlMZ{1G?iV_hN6_xV+&z;%L;N$zf<@ddx{M@Xf8!}xm4Yi>T`3qOEniI=BB#a_*K=%RF~h)74Gt>s^T&~ zPi&XL+-}BP_>X?*f4`6Wn9ppU)X=;>sbkPXRp^E>H#cV_Wd+cN`+RP<+vPUbB{hz^ zId}V9X}+{H*CmQaaVd)8a{CI=EgG>jSJ0(qdA;bx<-)Je?c(_7_Pfw0Ky=1=Tl}~@ zK36+b<5?Hxgx+z>jhVV|%{X(p70%GsgNI$*OHXsZ3v;?VlyU?2bC*jCGMA4tnm)sH z8B_4Tj|cIP7yU5J9SmYEF02>-xirn?^PxXlS&%WmU&+eiT;p!Vt-0DWb5E#WI&XxB zIVT*^sLbVWCO0!bOpchxll6+EIvbd|D`kLrQEIOHpmNZ>HnmOrY9(Rd zh!Mjd?SJRcf%n}#_yN~hCCR?*KWOmihX)V7&-I%Uy7T^fM+_f4dT{?c9~?Dm@O`6Q zmFAk%%uCNGp}`Lg9RA=y$DMOZa=h+=`v#79VCem$UB4>{L+&4S@4(UhAGrU)QFjh@ zeQk!)QhU9o1|JxVx>&PU)u7ev2CLQ6YI6Vn4-dNMzPs)od|&^22M!;8|DCRBN*zb# zsKHk4JLZVAjNJFNjQ;%xKQemosQX3@9@2mGz(KbAay&d_)ZoFc z=e3Zd>VeS%M~!whQ&%Q4m%#!Dlv&!0KxtrRKm=Y1toJ?Z-Kd??-Uz%Ics2fSTA)l@ z-{V{3laF~ywJpAP{b&7e1opURse9aG ze0$t`+;94+oT<+9&qZA&pfdF>|7?|NXQ{8Fd`ErV{|4?A{I1Qyzd2EDj8?2|Qzv^$ zJa1@L-#fMSzD>$u_pjP=b+NKTU9Zm4R>^s7S3j_4ve&oP_pW!me}3Rg-vR$B{}k^o z?Kk`R)ih^+sSTahzVh!>g*HQ7sm{TWzoEA^%4y}eQmTI9i#~5J=#ch@_J(havd_29 zzs>iKZ);#>V7qUzTCFbhAMkzUTNv1&E)UF8zw#Bk-}UU~Z>bag^Z83kg|E!_w6<#m3K$r?Z7vlPqj7PS>8SFGS9BSQMN|et*+3XRe$sU;h(IT+ClFY?{00CcfR*q z_IXrYsr}^NuWj@$_WsOvsjC2esa1PtdylbC)Fs++|Hs;U-nrhB>{E5IcG`bXTkBoo ztzmoBceP{woq=zZeab22j5bA+!zpW(ed=4))%b^Um=eXWyv{wdnW$FSHHb1>RrSH|qEPPqg*kx4b9V0kvHF(f^UQ$@{kV zd-jpKK>NkN+V`D*s&a^bslKEA;Qw4(?Oo*kjvZ9zq2(U!eeXQ)DfYGcw)U%kPvBc+ zuky3dS(LlAjEU-}B8YosbsAJXd zd^5dAJjdK$xLN?nTeey{9MzV#ke zmMUeQZOT05kXoso@PDW5Ru%_#29|Brrz(Rf*D#HU4Sp zes!5vk3=rYu7@+m-ps5p}ipyZ@Yjt1`tm!#lzMz3)5ES@+Z0ZvUI=Jl_Z2 zx0EePsc*0M70)kKJ!`Z{-l?9y_yUD!e!x3UEA?zre|EpDPV;Y8 z&Ul~muJCX4KND3a`OkWvS4-3h>Ui}9^(FN={7wKoQGF5RB=tvcdEkBZRo^(@kKR@8 z1p&Gu_8aGYC-9@EgjWR0)vatrV1YWzvmo$p;6={{cV%F{`jCjWNN z+sb5hz4oSWx^EF*?wju4&P^@4DzHf185ryP5GakIdRKrDdsJNuu0861TCU&=?{4o@ zP56KJjg51ADOOEuTA&=TR-?Y)Kj$^oP43Ogdx1*#L_bMKZTp?>AC(`KDu0z9+Flup zfBU1#e&tjA`vm_!!@ni|mHv+cA3@C>P>ySwl}Wze-Q$!W)OFf8WpChTb#35#T(1r64NO;;`~K9%Yd_jg zpVM{*p7DLI{0fY&lPtF@u+F#4U!zt5lYjavnKjCJ&B6@yM$}duwfz5)f2RMaccEv6 zZ-Vx$^09vn)?XD^;(qoY(f*8f&a+kd!+pSB_ly4X-W~oA0?+uX)fatdfWb0i?_%qW`&C(`$KDXI# zOklb14VC^q9iV^3fqlNYzW1Z3{?a?kwpC*R#jX!)<17>HnWZ&v*+iO&aS`RAZhFgrN)xLPgwbvA0=@o)3|piROv zbOrl6QJbSp_HEE!^sZ5lXrmbEZE-Z$_s&sfep&U01UNOZ4XnUZPZ>=Hfb+{ z{bwr^y^DQo11Hp1Z zS;o`vY;YN4m{E-~^s?d#7@3AAwA4JJ_u^-KX6x`({-tWf-6bJIj6CbD&np+3Gr}F& zt>yvzE;TbFve}TxqNdf$H@FJ<364R6g?z3X<>9xfstlI^PQ*tx%N|X|#Ai0jOxou* zs$4Xn8euesQRGiEUu^KQLcJMjp{e5Vd~dpWS;H)v2AZTy{l!zCf4W?RfAK`jvW8Vn zt1JHd`J3ShOy`DD6y~~OuwfA;!4(MTK2K-etNRT1=uoNIy2aGADa&YpCH4T5 z>;XP+5g#C-Wgmqa8Q#!T^UjvT*d%jj%TE#{t9d#b9wRSQVpg=eU!kcQK{RT5(UAtA z0uSgmJs7S+rVlidv-H`RzNq!$v_F>qC&M?o_$q}Ofpk;Nkr$sQa*nwpD|xLy>CrDrNka(#Gq93^}?1Z^WNRyD$3))-6`MDJ=%&%CxJ9v_I$c>%i$~H! z5|1&&+S;hh9TPSuYM<)7j(ucaZnRKK{Q+=zL-6y1#v_=@apNVL&=ptZmIPcFE{~VG zNz~|SiaX5RogtPVnO|Jdf|Z&HS7xD`#6B7332;@`n-oKJ?;es(@^gsWz(`wojHRl1oTZ43?&(8p^kko6Jaw+m zt4%Ll?A+SLmi>LP=K5>mvi$uujZ$e{r1eNh>j$7{JBCUsBG(RN=y}|AH?XA@`>$KZ z*-Pg0eJ^1zRjlv3lO?V$!!wr{r%;4`SIrqW)<@&DH}=RVo`D;!j3p>=1HQwq>A3pI ztanqt91;^_7v1?u!<7qaJ77$sE-KBJZ_?4jvYXb#)cbel!~F{R>BZ*ae)|(3@zCu) zX>|i)?IT)UbLq|X!4|u3&i8%fBl9=;mZPv3-`_%5Ot^JKZp=#1s_H^;Ays}GffLME zZ*2nPt-m!(IZS*5?l-@>^;>>onfbwOOW6eTiQDP^+}jJI7+IOM3<=A zTZ?95GgN}JGd8x`p54np%wfqdidktGRc*u<~Uv3-uca;ux zCC$;oJGS&+F8zoS>Nqx0%a5RmTBH5@tS+3YoE7@~r&*bM`VY8Z0@B3BCUD1qOQA|$ z8_)rm-#6fzdc?Ubk2ee_=&U7c5!R?E2qzg0r5kz0z!9lV;<$q(f>A<#ArM%p7p%n;@M3E+SmZyCmV@7}Vn9{{!K`D3&9F z^_xfT$^<^n-Zi4NW3eYXx*+k{Nv_k1C+H63sVrWps%)!msKbpBOhg91vc*1rX z57s)36oycg%J}3431-tq<&-AKD~>V466HIr_17m7cVAs*jdDYU22S*o6%S^2rKh&%C{$mf_oD_4)iFJ(q zOUZ_Pt zU-43Oh@b5~L@iGOC1QR9R|MaB^)tP~jso$%gT zpmAudx#YP6e9sp1h4KBU_-=e_$Z8Ogn8)CwBZ^eL`4iq?HRjFqhi-Bqv1IJz!ABR9?HD<_N@eddHQqdiXegLP)*Y@LlYeJ}i$c9@aP_UnFQf6ONC z@|wvnW&jcSFBY<~6$4(J#@HV7>`RYBB1Tr$H%m)WT0sOu0dR6-i{1e}XkBPnNJ-Ut zSLl5|*npt&6$F_FN{ZRj=4~$*W8BYQ?#uu1nHNuPj(!JDj`e$HGRa}ctXDuhgwFG< zKHYg-$=2~3%r=@q@d6P_7sQ&(Xod#nE#~EYCU11*xm<-HkU|9e0A@bHD4ENA23WZAiclV#@)PG-j5wPx|F#5c2E-D)qIy8T~R^rqK_ zbhqa1#Q?zC3al%RRUlzW?K-o|0*X{G5-}#7(`s+gy+TNbN}q$FoT_Q8rLgJf}tPpg_NH17Dbq`?ogEr zz<2-_1ij}I0!M(dLc!gVmGAlev8At&`~KovGz*xCzK$OAU=3(WTx z2GM-;!iM;*SxELcqr6#1>O2+QChMtCnaJ>|d`iYqllr`^u=LLBy*Gzsl6<3YlZHuHxPzxab+G7rRx0Reub{GTrDVafuPwHPT z#fe#S&$|(<_^I+NGqG}z?2|}8x6+i?xn|!Lq_BssxD3BmY9*&c(DV;3+sQWYf|cCMz# z^Tg^~l^s+?IgT6F+=ke4$(np+pWUkB@R|a~J~R{8WwF_2-nx33GrJ>FD!2yuFAiTL z-+f|ccPw|sO!JO)?OSc%Y}+XoyBDrY!!jewI2yl+=Z(`6GB>Zg6h7m#Tf%0;sw?VL zs$n;xgDr4oHOLnWy>32I)sj`3^Qs=_r#)t)_1(17o-j0|p&&8;(E7Wa;F0wc`B`7Z zhz<2vdW}z44a)vMQpjE8j5j4SXU={9iasS9V~WI03VbQ$QsTRS^R|1DUYA#5m%Rl26TCb>n>um2Dkyd zosRh%NaAnFlz1J|sJ%g72H@!@cbP3*Ac(;z2l zUi)KR^S2#Ym!na0m#YKJhotg*fa6rh6qY$*Oksf&p8c}fd*=d7VfBF=Gi6sY!X@lL zkp&1_ik~LbcGp36%KYP_l8U*zkwQ9U`ab%ZovQfbqx}|8QZeY`M$GdJ3pOqvHY6#;Xrpgx})_p0gI6LTa;s*bb2g zm@$tyd+xzTwwm-qjzW7X_8nZ#la>-2+nY4<>4iAMy ze|`9_%&)z{+6V)zXKa_H{)4j8xqom*o6M&CW-HNiyI{0i&GQAhqkQM{eX^JXmJLKsiQQ56-6MS-Qq#3f}mB}sXLE7!73^a9mC1GQuF(oynGrShq;O(aL=vw zzAo5y^TQ%ohDQw;`BLL`__60TQ-BJa`K8Y~sTMWTmm24Uv6eGfi_;-K<%DZCn|pt3 zqDjZkQp4Wk=Y5t{s?dJw!P(bl-;<+aHQP@1r%4z5(miET~sS&x-jya4z*!9qb-zt>=Vx`St8B30^48 zY$H>W@9(2+qS-W(vw18Md%#uu00!s+OBox%)c(8-&TaQUZznzf=3l+>d+M*o5Q>~L ztAK`2&O8V-^geqtt#;no1-N~~x$bPDIqlr57hCQG%@Bc`D|EGog+lwEm2(-3GQM|(Xyj&amc&XoL&8%WcC*J=jkwLjy0g;C zH$3bjb}@xHG+zUo7Dp-C0Y~r0gyPW-l*2B-aSq?IQs9X0bmbr_jXI%E#oIpCUO7%s z3ZS2Stc1-G#eSCA1h@>4-cPmkKCRq}#%blgI8?dL&t_m7LENFTx~!)136=HcY`gd% zz-|t}HOWNFU{PpmWs4yDnp5P5)ClD>^NNgL*Te%InJW1ausv0oD*46#Fxoz zaO&5R;pcgaLU5;HjeM~3qF)`>f;}ystHZ{j<6sKwAA!FByPOf4gI47IM7T}&Qep=( z7vhB!mfb-LB%u%+kroPxmkr)E!Aowx*CMjcctkESqXDad2CnopW>2#V8EYFD!?psFv8tVn z0)x8R34^hgJ7F+Zxf7lnW2~upY)_^PrYQ{QSY-V9r9|i!7cd&*vxNMA`Sg&*EedGz57mBMv+nzKD-!{obBshO*}yumf#f-euPGusi`@w+1=OSk9>UxS796T08~Q7F~b$AxTn6nYV- ztw_mYActO*ahpRgN{`;57u__FLod2%ActOb8{2Dn89R2l5u8|pRFlj@w?pQECzdA~ zw_~dUc7`ja6MKkD+Osei_NMl%4Vx?`wP)*yoE=yWilH4CnI#)4?*N%B75h4{d=%$9 zu#C=o;E#Y{dIUQlU13dmk5TXsywZX8kO?NW5|Ji8*bO)asF1x^knX{T2@}PfcS)7% z7N^r>=9Y{dyee_Bj-rd5m$FQK8;o(>x?$wx8@q_Z z?3DCiD;PT`dh}$~);KvLzn3&SJ$l6kyIxdN)zjigFZL2f9Nn9h+apej3zKMh4Qu=# zjF=%_y@uU{VNYIT4cp*)wu+^lW3+JxyJV9Fya3(y%MI*O*lrxg`^Q_f%LU=KRyCoo zR7c)_u@=(3N}{#;>1fiw-A61K(B*yc$G=$pS^`wIzmdHTUta9Hi48|_ML)^i!}_rs zfRT0m7|vme->9-i)W4Yx1RloR%$@;}{I{@9c%a)YkeH>FPoN-_F1?MlWKz7~(vmk& zdF*yJ2oa*_(;r*UBMRc+k?c z;_^GCIv&u?lO~?Jlck3x3tK~24eb$#u}Srw6Yt!~@)fCaL*U|X@048Zy-W7f3WcOZ z1|=mkLgyG_J>tK6?~?4@e6VEinSBZ z-NtCOIQWpqaiY>n8HuxZvwvAkKev_z2Mz_XCX3Rcl7j1pvf2DxwHSO4n@Z)`d)QM{ zK3QayXYKOIVQeAQHyv)(FR;s|_u8;sHoeb=?Xv0pHf)zoN3bXO`D!t51S_Vp=}6p1 zxnLxFoXRGnta7ehh99ut8Fra7+JZ~%GVMVNo@|#%4_WXeyHp>x;Ac^4=c`@tIEx_v zV#E`yk!bY@>qUd^jYp8d`Q4%8|Xd;z*Ud2f}q`zo8hd*wW-`nMoC)nfhXM^a>d zNvs)}j=~pMKL1OIfiJKgPzDQM0K2nQV%SSC`>Vu+m)P_66C%5W6Kut`ZR< zYQ_}mtL^ekr$*%2|KoZaHHs9(9O9F9BIEPhzTUh&zZKJzx~9zBB@7!8aP!UCPx2O4D@ zi{t8aLd}H`(&9hjAPtjNG3{EOO8Und-@mn?^RKl}Q9nQcYCMvR*DglH1{pZF1m<2A z!$kTrxH-k*iDhg;UrI<&N(RKlnRnXYMNWLlocIR2%)!kE9QWDazRq&O@Znx{!Y|Je zb=R^6;)x2@$B!Gx+n*G>D_A25;0T8}TLBxfROBvaSN56f=oyLB7o9K&{j3wl$mg6R zVdUSO@bNif(Q-s;rIiPlv(LD-+@YfW3f91J9T4xXU>#$wGo^IJ*%d4UK0w+^#O0;p z`IXZ0EMLi%1G?uu={3Ln9@LwKEV#SI^cmvOO>FSBS+<)?2~LTs-)F>g`7*il6W}=N zFyZf<@RzlK+o;Aa#aOX@728-~jgyWZvE=bHFYKY%37?)JmaJpgr5C%`v4_OJ*05d_ znSi7;pF*5YyXafpa0gw548_5TrQ;lIATRjG9X#wOPVY*$() zZhoKLV^1pOe>|xcqM(}X@dFb^U5Kf7BfB>aJi3vcviYAl>#s86|Gy3SpRD5F@BlJ5 z61P_|MfBXv_Qi*4vW49f11iN9yqE77c+D&^cPp##&&DK4m)!9In;mN`{2#KxF`)8+ z4_PNp!r*}mjC5KDS1V}Uc16aC>2VSD7!Zl0fNfTgNzOw~7_7732}2}yIbpEQ7AFkW zsdB(>W5smQW(ON^DJCNGBiu+VGS1gFp%aM4A5QpWEx@e&-Oe4X7cmSvpp+##c%@cz z$PQj|!q3eR-FC`M#o(Q+Z>pUnNSF2$8C1Fu+jp{w4ov|x>;+2WLYjx<3E;Sd01een z7-(4Sgn@?TP8e${cfxaP0XLoTi{Nlg2l4SPHeFH@alLqKH+x+I*tZn9dsxvBd*aqE zA|`%$Yz5ZY7SwEV#j0>#-ENLuetC6b8dxOHCQV@Wy*PV6AeN!P)F=yI z`R*r3yz(X0qTZ)$3LdHWluS$I!B3HNL!S7=X9y6tSN1%>F7w(vPRBo9*dV4HvV=?S zoLRZ4_u?5+D>nt$CJ%B`wSZzwlZK@IVfJA!@JuR2U8%H5c^n&t_9>-Q%6@$d*zO^f z49yo#7zF&-3Gdh-uKkJ(P36e1U=Y(vo?%F>gmkYl;|1hZXo^UwF8Z2fcbn3skO#5h zfUMOvx<+0U_dWIz{4)7qrmR!!x+U?>J{Gl|B_3fpnN{&y&mE87atFO4`3TFbUwilW zqmH|tfPoFm&{FZp5f*7V#lgo|RTzRj4@sm=*Er#K-V>kKNX9)^!|Je$WlFFVhri$?Z;3Ib ztSq4uVaUGWz}?R0z)gx&RH4vE;>zQ!he9%DBxBEQ%5hde6SB9(E}W3(ZxizTZ9*Oc z6FPHTYUk{q*vfp;Rd#Mi&!vqiRnLv>_~wusm#ODSxbnl@~c76~*;P?mj)pB7xoihR$n~+%i2g{-zTqOA*>zyOAXh(_agwWIC z&>wQQWbmJevycRR|4;0H?h(KKDU*F8|H6Q!V(wq8QFn=fdSH&)&65p3BC zuw@W}D(x50c|XG&4jB6?Me-R|7^=p3fv{@$!U5VZ{9uc?=?p^e)s>?73@b?3?gtl9 zDqF$vGqLgvyO?jR6vxl7X8eOnk#m+cl15Q_46SgEV`E%J;#?QbaX4Y9)agzbjPQyR z24}wDgu$85IN`H6=3(n!#h8KwSQdCCPpmu3t|#`w&T|k8yij7~5hRDisQ)A}z0a{j zplyru>_!m&ne*&wcC*wDbc&@BsVg<&m3uWtT^ts#os(BemlG!Ga>68CPWYXTB9Fml zjjim#crMG{V`uB-Msz!=%s{Y4q!^-{cg;j1U%{@F@j=Xkm6-l)qxhWjd%9p=aB(!a zI2W#3x;Tzi^M6=19riyB;Y}7x3VDvW{V>ZGRc=0oY+wQ{mJ$g@^`^KDq^$sBHDH?t z335;;jK!8a;klbcnTOXyu(i&^e~;S!hV6{Bw(yGiBVkN#NQoDNOF zdNQLmk?bbakS>2#;rX=(XX&8D@~xF?6+VcZn6So+P@HVY)5UC!mj-}v+VFE3N8b}& z0{m{9nM40QX7(FSC4T#&dDo!)Gxwgd#0}EA77>HZpgqN%mzXge5 zMMeTYXm{)e`q1%dG_>uv?D&N9L3Di738UjfPI&(+(J4_%!hl2^=Z$&Y)=LdQD4oU= zQPQUzR)>EIQ?V^@ZV08&;{3Ec(;WXY1n*|B!ycm@)rb`5DO(z6Y z{+!OQaHG5=n@?idbOb`0vJ^69-+o`^(o<|xb|43s9b0)Whf7m-QC&`^tY2MDrmUo{ z#QxH{*3BdJ_*0nfo%MM?_Ow`CpVN5|L+3*M(DP;)gKL z?J7-D@B)*BLx#KTeRRLEi}ukyv|p1-$4YSTpqKVHa7sUqAMye(@>of)2_MJqkjfNE_CS3b|pOC^xJt_cjHFg;jDs{6-Z#KY2zT2d!|Z=j{T12Z)%^ToQ3|b4kQMnoA`3D5mn8S>1Sgw_d4PL;yIC3e+>DiJ$Py10)lF&jPgZic= zzmv`v^k~hy;Do<;>0(LE_b%qmXqytgMB{j8;@6A$-PpXky$!Db;gc`ny4(9^{51qM$HvyA3Eacrtwqa)In8bzJ;s0tTW7^@Z zLcaSJs|Os@_?vc+Jvy|5?9rhexUr*FRe*O3B9h}9lF#Qi8bV)J?rF;}B|kHL_714y2T*YtXSjEi#Jl$)}yg?U!8G0Ysh2MtW|9t`2 zp6tr^{jHO3;`wg;U;o%XU)wjD^FForPG8Lz z13Gz|q{4xo{MFif^Ljz<*NTR{A(cx-QE%Q6obgs~KAt^W*{Tmm)^L1f>uWf6p0+k8M&MJ*V7QPZ@nq$AL^e@g4rD+-pGJxSO=^#XlGEK788d%VcBsc zJlvOG?|t5r9ZVNXZ{;n(DQElg7P2NKR@47qxDkJ1{l9pwXEF~a3idDFRJIJpT6VgT z--niO-zd>`_(ncR-dAJyAHE4T@rc-U6PW3UsMilvd0vd@CtKfft0aI8HM*I1LX*Ka z!Rh5t+T>x=dK*)9Cq|EQ-!x5}RM+av?q6rFV&zXlHw6l460MYuoD z7M*W{F}Cg`*wREP6$sR_+quE!ic`1qo6w-w9sCkZ@aa4FwKf}f6FL3m81@pT_2&%| z&+LNC=NYGVBTe`_lArytVOKT>8)WZ`9RtAT%S3P>uv;T`J;~eEkz1gJt-0acuE48?IHW7S zzMIoQ7BtNg*A9g#s1c70rK-wpLwOoy1-`lmT40-KTZ90mM%-A$d$!s}OJLwe4i(iQ zm>w|3zx6(CNtUAsO{R~Ct)_~G#vxfDb{BEIaSe_o<4l)V$Hp=)5K?h$2)-Z74dcbC zBBNrC$QZ^S#Xv6)<2_Iu7{-U90A6y%fZ_aRT-&P)-wSQ#l4;n z@EL%9cz};ijS~as))NhzZAOijY_nvvr0bWXf&3cL=0V=A(Bc^E=^E4KO5|3du(16t z<^*g{idE2_daT2x5Av)SPwsjUC(@73zcLKc;YF(XSBmwcB^zWv#IM3Q{U74DqgeA0 zzq@wr4sz|qICfMkE%?DX;_8PXFY?J;vG!q}+~~wSyZiF_S4QADlV$J@>j~|Jmw&)9 z4DoD@s2#A081RT(>r0RDTlqFF4&N_14g41t1&>Np_Ieaf{&De$1(iMuk>4ivKMHNL zOkDIBud7vJVle&qw2SEX7zSM?9(^n>cjC}vI73?7bBx&)an<9p`@0_J19UL8oGX5m z2p?wf-kvC?47RkVd<1XfVc5@~;LV!FNoVXLS`-*(;;3haj(6~?A>%nP)U~6^^*rz- z)Xy?8>&e*U1_5`H-+DfUqi(iR82J?5-2Agd_@n%7Dl4P>9oV9Ki?QydVv$w+D2vMG zW8iF{QDxE7JcBO8$Q!*G;*7($ky-q z@YTJ^{Q0yJuYps5@H=@_Pq~8iLrw?19iGeuwOe8$3@cIDAUm_5au+}wbnSgCzy={0Y*xg%CmdJ;=zXI z@xJo42B_#^@cxND(s{#;0sqmB;s1U^jGoFbXWxj5seBdtUfeHu`#Rs_=m))jp}UPk zt|Gip^1XOZK=FMq5=+tefaqPyuLo3C%2T8CQHX`(8PACNo@#*D)PoP-HFWXLv48aO zJNmyzP6TG!4c}Y$^`=8LZZQl3`^uL4i~Ksy)IQp z_u7C$`Sg1o|#b$+WfrR*j41MEVF#4Vr>znS z74hV|UE%sbZYe$&M`@2xjW32h@$#!YJBpKpsdUhRq0wCWrW~Cu%nZE`bSirNw(b(p zir!xcr-Kzb<6W(WE?qMUio$8AFG0N;V+*i1r_`u?B{z)MeXOfOt^k=fcZtVP=xupJU4JW_3e6<@r98C@dnOt(P3Tbe zY!7I-0^uCJPB;S%e3)z%eK!TOO`tP5idDFH)WF_=y=GUo5tUGG1Y0+*Z0s+&x`ngQ z6ghwUqf)_fz#ksS3klo?Ky%&0Ze7`!!0w)QG3>8X(vSOYo13s8TNQLiVsQ z4g=-!YEPJ6l*Noxc^*GtC_NGwm_{t$qBV~aYO){;QZ_fMP4$l<9_2C(Z;7Te2!oI0dh{VS|O9x<(GmFhi)UBCJIX zd%!iuI2tiW4yoc6AB~N8EHVhjX0(uiNPa`hY#f9x!pd;CCLDyUU>yPKkfw)rSPKb2 zP|UbFphsiPu)k_60O*|*ocBha*j*Hs{HN!Ty2ML33f@Y?;&Uixk0J2J0U0DPflE&! zTM7^ej0ABq9_Xb3CBNxG!_~*?!2{(Iv}h25L>f^@EN;v6d9*l>s^CBGxU&N&mIr+OyCylCg}M5SQ$f>CRE6$Q3<$|$^@enuQYwl zv#GT=ig%RpT~wMq2w^V_Q^I$AE@i8!y;{gu5M@&=o?MPP`iSZhDq9xva=Xnug2B3T zZCH+twWF~Si{gid|G|wO6ZM3=DC9XC%Sh0(iB5@y9ItuH!Mj^?z6ub!MGG3W zBMNlZ&brsey4T8r3Q+h8d7jmzA&N{I4hf1M+B zJ*6uSTF@(4MA|ywe|ZI!XZaqGDi^-1fp;E|-vI;QX^KwJ7hb0&Rqi8wt0#iZq2E9` z`p|{$3#ZUY(G-|S!v%Gf*gMDKDH0Ogh^CNyP~?aP@>9FW^1(EPlc5{vjTY7ui7l|c zE1Yb2!Y~(mzrIRIiu(s_L2F)1C+W^<$5V~8l@GvN5jZN=%{3p(`gpE3Y=mpcnl{ZfO`m+ z!AaI|MX7D$Z8C~Lvg9d9Bl-$0B0eLpA;BnPL`qsXxIP~oNPDFTWG04U!JD71!i}hL zlr~I}&dlTeq<4ag+jM-&1Ytccr;&W3EMpe$lu8c@$F0!AwlZiVI>KsAAU=F;>)6w! z5Hcny?u$vSYDsMrYC@L=4eVs+wIwlxS19DUFe*g&9hea}|6Uxj+aqb-Sji{uc zg7=a0N@8l9Ie-4Vo3M;G@sKuy&jnWo7)BR$$de&+Z7VD~5<#*JJ0?9!sebV82&7jk zN?QgqbX8(BWF6B{BPrwo0RIU^#)J>z`x!(JW1JH{vo(G*gNOwq>mtSAg6+%5cZVVn zXiK+Qcw>-o+@$yBj5KOSCu;Q+>k99L*>#zux&yF((!T(~pvcIQgDAj=B4q{_^tkQORRb2?`Q(fNO`>lu0Awljw2}37D}i(qld)0#10FqhR0R8ro7Wy~fli$c64g zDBwNPhXEi)dAcS&=1^O3qGpuMAVuB^m1S@qeQkLgv?iCbkQboD;>b}AeaO+jb_vge z3y6s~B)^la8^h4xNPk!SXgx=f2M8xs&IA0HeuaxhNtXjw;W`u7p0=1#I^j`4;il!{ zU@|Q?-SE?y%5-dQ(}PeC8g}fg_p~Q1Uhgv6qM{SN*zh*4t5Fepjow6un}3GGZAN*T zLo!gF;$b(B;zSM(5%GvBe6R6A_sF4m*lS2XiyPp=`Y@2-I!4}-2M!$Gfdh(s}%nxnOS7fT~S!5w_GsmSorCt~FB<$4wiqqQ4>lGT7X zo3vXD)@f*RN1*#?qX*OVSWHbu(-IKO-(v4>xRQO-u1o+O5i4V@dC-XVWI&&MKA^2z z*IlIN6f_Ba4uL{YSEPGsLa^qd)9XCF5p|(JD}$hOxuq}=+F0(WBs1O?c8QX5o*|N! zaC|vLy!JY89i2dF4P)BAcq}1blqQ~m{sY;(Ay5(9kJN9QND3A0B6UI={CY}Qwai5t zW(@@=h0~&b9m7M;v5b5ZKm!#v1iLrz#)*0^_z>jIkvD;mDu6{rP%^^Cj>d?7^w zmsvo81jxz5ojeJg7>m=U^4se)K9F4(x3H;*-NZEL{75RmHZ}-@ka-27TWiMI@eD;Y zs$+}H6`?a%b;-nrsPMqKLbV6yEIMQQxun9=_1u>1MGgjsHOw-i^u0RV%OZKk$Lq-3 zOb08$bCeoC14oO3!zj|TR9rgQq;&XM*zI+})F;!Z$$Au5J#ygIMkta<9;RpHL=cl+ z4aMf_K8)Tm0?6RBVc!i38}g3fG&l$Nns6@q=A(g%5+2Tl6yUpOBz1XkOhJr>dfj}i zK-aVLp^WO&vSjF=t!s2MThAp!8_mvl>u5xGBk-D$9hF`PEysEu!k;T|2S7wCtcIdX zL#T;OLMSrw4vHdye0U!u6WE@Y;sakKlO!u(l)yPBsuQ>3Zd?vYZnLALshaDk+rsdjX;loI#s>}#lc?hpD>{|X)|80B8?2bCrCbza zHK1S|ss^oyuHusU4z1qD-yz`$t)k;Q0;hDwIvysIZN>Ex*Rd&0EBD1jZlQ~Yj_PVS2+_e^N~+~R{`F*%TF68YsUif;gsPl;j`_Rv9Ab(BOar9K zf#}<`qqAf9vUV~R$rQs6iv*?nkfUc5@?1QI&^u%mK@{-qQVG)4C{_VWlnE3Zat({5 zgNx#>0t_zYb1)EjBCI!L1jEqX;IqKIHYsSaavkn|!A84r&% za)p3TdUwEyQX&>SCvcQ}7Q{*p2b5#LolrO{0K{Y!MY4@lN=V?bVmt=#9Bcta1`R%p z@CUO`B#p|50d^?gJ%9u}8w-w;Hakvqc?aQR%ywurEXfbi_n)bh4D}6VfQiF$LL@;j zDOC7%5DoH&=PjC9&KbbIH19m#E0QJm0Q9V3hUcL$B}}t`8p_dv1!YQ#K1>B)D+{x> z%)6c6q{pw74RO&OOZ8ai8|u=Ev|0zVF8D8>2eERpfORd$sjdtFfHkZd`XWd~CwKOL zJ{vr)P?}fvN0_&#qZv_rj=%~T6lfe7D}jyE(Z1HM)zj1Sxk9t42b@B)wJWkYq#pUF z>8K>ullP&%DIkf%pjkR}dK?CI)4{-Tm~3vk&E)6+19wJXf#Rx&{DfIp1=finBSByt z6Q`l=&xMgn4!z?>Ehw#m?I~+1)jpo@XnkW6+-$UxC!K&_xsZ-+5kl3AIS+klQQ+cq zNU6Ol^4$*62d|*`W!TRH@Ksb}1wQ&^eFzA~%8DxC0>C<_Tdn}602r}UKom{qgQIke zpM0>RcsqkM#}T_cBufm^YIp>OC83blxb<|>e=^!JJfmP%VT7SOl2Jl&hckeLWK1Df zA`ZfYeHpMnk`z#WgiDey0MaqG%)TnFpTW~uKn$J1BbT7Ve7EJ4B@zoJ+s;BFiCfI8 zNCaWx>KaoQ>t^7n%{SuH8T{d7EJg;5a*?!XF>oeNkzcxy(+;h~vW!D`YvGvO4UU~xaE9&;CmL;CVGU+IG%Qljc9?upw8%hXn@(nQa}g-hPLG5z(F{GeNL=^3 znj&_6;|qzRKh$IdJGsQLxki-EOL}9wHSoFVX(R|*bi?){UP*CV4MTe3HFD=Cq-Ws$ zz2+`g#EX}SWL#im_rN~jm#(h(JshtZH40#huA{o3Xl1oidyYhZ(4E7gz!yda6@a5$ z2+ygf@uHsmjy%l^72^<6Srt;(BF5+m9)qhth`0d>1xv=`s^8AG|%vVMnoRl1%vo7RDcmCfyp;v*9rjjL0 z7$}(@roGw_?O%A&IHD4r>N@FEm*_OAOBC8ZMyf1}Dmedva2IQ(`C)Zl`q}~v3poz5 zpTE)Drm5D0=qx)$>FiT-BlScCkA!HB*x%J)2as*bq3r|(UT`+$lydY`=ndLYCSEua z=Yd!6T_l2yTa6@27XSgw@LVH-_D6fM= z1>6b65EsqjX;DBU0HDX=*1e%9;HOcZp@qyAkxqgLV`pG%+y|DThORRsbg&l}v;l&m zyA`$Ks+U9>62w5H9~uWSJ9h45%#MWcaAdV)%pL`1y%e+~n?*{4-t0usL2pY+{3B@h zBG^DDbSfG_JAFhI1;P_)lz<$WF-W5eD|Ck)($j|NYEA@vbu~yC3*A9f8M?y^gS`+0 zK@PE{It)A$#2B&QJt%IP&Ff{x_upX#AZ+&jyY3M$%y#U(lgXHd27ljsN5Cz^R{W9= zh=d!mo;WW|87^r-L&FGPCy>BHlPbiEG8QE>D^rWm%CgSZ$`P_Jh;C&aV%sQ8PNacV zIZswja+4W~G_>l#(;T;x8kea(`ANwTZed4^S2^(rnlUCEpE4 z#pxnweGUM7fR0bRC8z2#Cfc$b?hAj)hj^ zg)N!xWpWjW+2Nrkz?a1y0_Dg(_}m=V1H853~F-(Tb^s?9Lggyw4cCRP~M9cbIbpo9R@D~~H<0wm>^`}Lcu^K?W zIPnIrCl-WTAm*B(f_3OUK~5yztH@ zeG!U8-Oye%OG31pvr<+ z_=LRlC|M(kIFI2TNjxD@hsk@y%j*(TkP|=yCQT~GM!Mm)j)~w56d^X&7r34McVMV; z&<7*Sj^%7am?TUPLT|fkHVhGERL0o&L0o_(-~s_7WQyM6k3b4#IwMu)5%5ueAT2`s zV5GWIDG1MOi{;2GsKaY1bZdj{78LEEh*7kP$YsE(K|A1r{zxop@R>to*oo3n>%N>O z&DqYWQvQ}Qs_xDd!N?>l;%QlPZCl#!r88-8T4FN<+U;psc~^qKT$UlA*+T7DlZHCZ z#EhXQ8xnaMN{dJnlUqMD1z0C3Bp$j?$9sa}j*4JrV;mqNHL2!l*a z4Q0mBl$enCIV7fa4rbzS9@5JzGUZH}uw)tmak~deN3cm|Jfw&J3I#y=5E>NEz)>J1 zXWB1b@qlr9Jhm#r##7% z$7osXiMYkdH+kBfAY(byG>PFnvNXV-{S4?O#|AyMij@P6fqa64w>lGG`UqBa39{S zqn!uXbRr@XW11#MI^kU|^hR&y%5(z;#1h5<+c2Ml_M!B$9*B z3~bMUxoguj_?(%GbO~)b(!Qq$>IE%2!m^?047NmZ6^sqk4Q1HnyMR!liM9D0Wath2 z*`u5euDei;P0j%j#l(Exs;#@bl<6p(Tb%bs+Fzb90YoQ9&=%MzMoIOLpg{F#t9Aqg zBB=Wj00L1soFWDN39A^6Ci2uXecl`nULuLJE$ie~p#sU;cm;$%z+#Y|D89TVDeXT* zh}53)XoAERcrTGsDw0i*7sn9`>dvMPa=CVfD;ab`8@a>Eu)T__*fx`n91A6q!KsJb z*4w5^UWn2<)@f_h_eJh!JQy>LLUnB0!K8s2yesd;wQTq>7YPb-p$*H>l{)Vucq)g)BHWajvUC8_43J>%}fd{Td0W$SMaY)|o zZr#2L#Q|B-8CQ6$BNZK7?NH!PeYHXHk-XgsS6D;=irumznukja&=3V4&{1FoxhUS3 z_i+l9=$VS5N>+sQB$<@ng`_lno5WI?$B+}vAh=;J` zEmWd9x*r#`#e=^UEE^o88+-8-oD>hV9r-G#Q7mr;zOOVZo^JH6i4&GkE;rRtHd!7H z38$f{Tp-TGlNU=#Xq=%SZ3frC`i2MD65NG5FC!p&y}>#(Ny<`YDcsg^W9gUrf`=ot}-OtG2(&!CTHV1nxb@B zFllJ7T9?IRA4i1#lKzbJU(m?uztF0ri-NcukCLM@Lp(E|H;DQz&uBG^c)=3(S#CIE zKClDQhhNtQh92VpMVBrY{>-R6;S`HS(VDE$g|Vo|ibbu~NTSL3dMIos7B_&>09J-7 zdJ3<2pz1Dg2sjS=Hppo z=^H-(hr4%yld3rL{-@8Wp8GHjGsDa<19UgH0YOkMDr)3lRJ;?T(M^nNvS!x>O@eV< z_f2Atf(8|JycQ}kh^QpNh=yd)prR7RNDMJ#7b8YuNP>naDytYt{C|H{r+a!}Kp?)p zpU+=D&grUCr!G%D_0)5#r?fF{e?g`V+x-2Y#f4Rgq3WvG0&nk5M$mGqi`jAv5Ngqa zvs$^s_dWol4rd>%>hK+PULLM<&R3-@RhDKc>q>HMCJp1->ICeNRh{La%*i-rr&vVh!mOE|fiuTL8O$~5Ite0Z9Mu`Eb{d0| zm@c{!w}?D7U5Pdh|AYxNq0Su%6sH(fe2(QP8Zteb^lEw5tE6b;c$4NfUEr0JKAHzg zUb+UM@k#?V=Ko3Is5W|qiDXGq4w>#4M8e)bscIzBElnpAfiWQq-=Li*j&O(^!D_CK zT^~}2n|MH!3%7cM5~M64A&K&s^R2_iq~~U zbmBLV2DSxJTN6EBpcCrJxn8$cwCD?KUNQ%&fGE@&FP(fPeB%m8B5Dx7!b>BV_1lY z9Vt;$(JJ9Lwe!VF4vKsCLcv4top&MelY_oF(c%ul87kzc2xMrss0hbOGD<*ui$kUQ2S2 zPz&Kp-RK5%hQr6ceiu8nu#0`Y$ zvC8j{OqA~lD0GH&5e~hpZdnpE_GLI-_$w6%SeWi>M=c3jj`^!QP!jviuGKwNZo4fl zs%~AV72)cGq3$+3^4;(Pd)<=Yz)Ckfb$^|Gc1iH*S}e=e=@QAuID3( ztfnPUkSK1GY4iK$X)Dd8oP>D1=tkb+;u||8sbvS>o#?%t~G*Ztr<8I6aQM z-WmQdXi4M)z7Jj+M2XUs#9=3({q!FNBLe~^%@p^Gvwde-a5Rs@A99ab z{_(7T^m*82{?o$&r|vuNc$k1gJj3NajKJZK5GsIE_>Tm)@Hq8R;*o6bT=Qsffr8y1 zxq@%z+Sw}t!X9+~&x+u4`gH6Qs^S4V_sQVXyxshyi#afCWiWa8<>egeZmmkWXG{F- z7eAZhXA{rP8&-1gnF0Lrr@?1vxb3OnK~gV16`aCj|ED>!e!2bp(`d^sx8Hc0AUvDx zT~8B^XmjW3tAa{;VZZoHa0QQ7p9#+6@tL0m->q}4a@>wx_0U8s7evxdpJ$0Z)x;Z) z2WDjQk<&F>97utY#h$V{n9S!luLee!+x4qm^ol+|5B@e{tpm6YgJOulfgs@q`1~m7A4*O^Xca!2u#!{Fs{Un^&_nr%`&(CZ0i=awiJaG-~ z@f&Z}eGP4P{+b{|-V&mB}=0rubRmGgvcFrm?CU8C`pRwvGGFqdpf{p+USTo*_32LFQA{~ZKmE?I8hJ6c}M_H-EM#Q zD#4K+;y}Zwl7pj~V`^Z+Q?DnhIfM{Ujw_vNUn3IGMtj0*!JRbt`fIMi%%3?sNSLEP zZw-#NZ)^_A?8-m0T&}iL-*WGd+Z=qp_`M=Q#jn2k7yoMgUxL37O6X^=qi4L|9{&bm zT?%EkzfmZ2j9suLc)%At%Rcxffh%0;3AX&LKmncNYG=L`v^SDqmqFEP@gvo_P{_?xQ{H|7ixUD;w zO6^(i1!wdAvG*Jp-+C|jm#);6e|4#N!0Gn`g|3QIcfKFAr>l<$Ey?)i9J0)v16BfHt1&$`dg5yieqFk-Ag-9`CD*yIa)qjSs4zrze%)r@iHGeK4dLC8$dP?R z1+eMp8*;0RUECaIDseAp1IFz)KWX3p&$5i&)*RN_@r_{<1x{)VKfuy)Qd4*i|$A9IYCj5 zzjCbeo9XbXpymN0+SZ`&js~z-bk+|F%h~E}{~_UNbo6UO!lMV=R)}t&l!)~w(q8)l zfqVHj`#(d%Pw~a@q2WSZ(h8%iAYOEaS7EjSLTN0Cc_C-|-!o zE}wIB2HLwDM}-f7!_SNg(~*D+bxZ23=gQ)4((T8J)16%jlPRmNghz0vD(#5lJ)t#q7B+GL(jv?#D<4|XJ zmPtCAVvcA>7V3$%pfnfcnW73Wv*3Yh&zusjVp@N3S~$3+QcN|@RhaC-bhNN&(GzK$ zyST*QoMXfNp<*{48{SON+Tq8A`x(WawabqWFXsDS9v6=4?bI(~nG_El6nfs)9v>>G z^BX6GgYEsthZX#O$Y<^1gRh;C|3G1I`=1!z%Y)91`kW87Nu>mSYKzy2Tf*sS(U!sm z3LrhPu8!$S`y{%(kD_OT?6p(FcDh&lsqo>C0~%jFH5}B- z`8fHBR9w@YL8FzsZ=jLB^dkTb-MkB^)Sve8K;`t$>;gx6?K2>-Cw&xvpl5^Z+%v-V z9D(nv9!pm}g!4kW`muENLqxdvS4HLezp`u!J5Yr?OJpKz|0x{UeI0?XU-)d;m&`p} zH(1s_3Yc8+Pr&5q&$)Fo<;?J~QgJU^Ubk1B8Md9-2iZ{P9ILR<>3lTujysy(JM}7N zK^MHMKGAp4ogI$M?dU80jKs0P_69t$y0t+98$n;fVZXo2h_ z$*6%qRVXy@CyCZ@^5b{TPMSpRj-G)$^m1wcXo`B_C&}?0aR4>&M2RRqU&Gg_cVvUW zwS}-Fd>Mw5e0_3JotC;KAzRWKG~1%P^b*%(*{E@}6A3Sq8;yK2^RhKrdM(%zUAK}h4CWhEqAsMv`&<)is<}?+T;HYW ziZ@o!Ts|BRM|U`#s4h8hGHBVEn0XIssY`q}6j>&R4Z}rW5-Y>Bv#%zj+24I!tnGX^ zS?dy*Evu}L=5sx*-!RKX5i{@1pZdPx2G?Pjw8XcR#O@P}4rpM^-{Ha1* z+^GyOUp(A5_u(Q&rpvBV;}FFStnp;x5GO|G~iJ0U%Oa(G2<7Fq3o4`)tp zyJ8kO?d{vkW=?Lp!u@RDRy%WY`4zKf@kQbatzk0wT|3*CQ~p4H^Lcv03 z3!t+31IIK*ZXLO6$W0f@&L%fQF0jsK3%NR&(T`jvBirI~_hUi?$7R7moXG%kh$Os3 z&A_aqV$qBZ@Q((2=YNIuxfY))P2>B^$MIBzK3VBsHv7jw|ETkijDPg=5BH&K(Y58} zGJq3T8v(EU&qe%n5K@n)IursxWC5PS&;SlOfToZGV8{V1g&crF4j?Jy0FWCGxV~>) z*U&X^N80Qcz8(%so+I$s$G#K}FLmT@p}qd=;o$N!l}+F?pE|>*=K0jAJ~h{;rux)P zK6Qdmb+}Y+3cVrH3ti&q)tw?nmxE(zMLc2}pi&Bhk7`Fg z&*PJJ>|^JGbuT)zdYO*qe^m{-00wXv%L4gMM3oUshgF)Jmih(U296sV%em4MvFhK-uk42RB@?~V{c0d?-3omfcS7Muqebak=lx+nmZ5&w>s3CRT3s~2pb+S*-L zq;%51T%l_ASyve=b)*(5Upj+5y%#$2cUi#QH9!QF&fncAwCJ}55$h$-|R=ZH?6ov z+^njNX1L9K?K!G<=66m6se0lXe3aEwJH}ldTy(WJ?NmD+f&%1+L$}A?Q@!&6Nbgkd z?y41|pPx47Up2E)i2rKl9L&2MH^BR#l!@@jrenJf7j$kl)J`Ha!uzBMA!6J@&?v$! zuEKonf!~)-AdKoRae`o=<(XZh6C9yCDa$bqI3dMeC>L8>4)>GqAX_SRWGnXqQynb* z_q4wc6?o#-g|D7%Eg%)sqI2-x)0Bz#7J0vF>8S%|++Dnsx&g9BP!#6AsR(mvL{+aPHnN*Gz(3Ie*5Ixh(V0W%b>A*!RphZBlSCKx?;3Y^MqRMU!P1dJh6KGXPd9spI$vdsZqDV;36b6Azg(0R z$+C;GqReyEp=Hg45_wE~*i@cdcnq@5g!120c1{9FaXunMPsJH*57}gbL~JynWK8Xb zpTu0sV^XG4k7e+;h2`S5Qi-I+_?u(P(*UIHFVGldCx=@_+bHC~5%_rjR1}+@_fNMc zpDTA2#{it?yjpbhx99EBn~g(}AI(-n`m2%)y)ede zFXSHwe;_CJ(g}1$0+8dyk8tEu?1GDZfrJ|iENLg!ICcTP0|Ces3qVMHP5=re0O1CQ z0OXFI6>5nEpd2jFzDPg?p+?MW%o~fd&Hvm}0VubR63|B_0Oj^Z0!kJ*aF~16DZoVP z_=g0bFYcoR1j_7_0F>-e04n#>_Wu_FXhaBbB>oJmz>k&R1iN&yO9lRUF6l*}irI0} z%Rm)4x4O4p2&!n0lU@p{z=zMhjm02@F9qBJ3E=f52UW62OVgE35k-rGy=dQt_=BC# z2k#^sM-nY&NF*u>8HehbM;GUbUmUgJc(CHr==?F~UVZ2<+HjjT+BNz5J8fSMjvM-p zR?L$Ca$BW??NO;kKF6z^#I>(VEvR%iUub$an}B#n4d^QRgyWSrV2~&>C{Q* zNe8jPOww^Z&X9OLuK1)riu>k*J@;`MQ!QK{NvjI3fqHa$ka}R{S$r1F&`B~K?T_EhC&U0G>%a3#}9wC3OUiI`Hg2-h2G zyxJUHR20WjnZmG161So=kHv!J-8q_TKBvr(z^`m2=*~*-!dL z+h{3(yOTn{Z!`-PWdKV16!q57yGnakdpNjBcJT(;NlbKqNQ+4G?HpsSwlBAb4TNIW z&9RA#I7^H+x7YD4**?*KJF^PNbsqA4uYBxvvdcUKB(xtD|2N4yN!{r#{+s=v8`UssgooA(&Az^&pGBBvWoLy)^8bs}%EVvbq7@ z9cV?=n=ZtbDKDj8T9H83Wy%IzuV1l!1U^*98xR%LSyT<>j`?+6^5=1~BCNz3au}i_ z3`-nuFip|0!gQ{DdK65TgeMeHLl`C0elJcC5{QsPF<3de`r$pF1qRn6!jJfiK&UDi z(*)skA-b}(7G8~{vl1RX`Py|yT|dN$IkN0HZ)vsw)*Oh5&I;X$)}{tf$x4W}qYE14 zkB?NM7_!e@77oaj(OBHBA!Gy;(x3eXL>@@?_$9dRUtCN*_4M3Mdp9c_{Uu2(#e;&XLKCG9sC7dM!5JqJ6f{@0Zhy@WNwkUL24dlBDjE}l z0@(mP-{LPX4_ockmxq;^GWIZuO0j;#RRP+#K4*2Wi#>aG*pE)~$$mLVk~`0%KjqR9 zAoWPC1#I9z91|+$(}{9!ZMpzb4%ZbeMusnZ_(QMqDCgvmBuPP5{!ay{l3A{!T`p7I zcFQ=OoOX09ebEaKo-Sp@?mEIsmh}xu2t@{~!9IRPs2dL*6t-UxR&oBY{9EDh{8ZF` z>{AiW4qJl16Cq+Y9lOsSF+1#=g!%;q6#4pW9C|A4_hyF!4=FOwF-_ggb4IZji_LRJ z3^a$$L9RP&aAkP#QDsPDE`xB4V0IbO7;8|{7_s>+%$Q?!Jf@SMH%FDl%R@+-Ewi~R z!+)$PzLQAXjN7*j)UhkALi767relUKBdZ&D|nhtmbS(wf=3r zfAsQ?-u}^DKyn|t4!EX8CyYSi>v3R8kF&qJI{ZeWtaIv|@SBMm?F6WA-QH1Se{)UP zI>fnaTn=Lk?E4>@K!nzg`w>ALWM1MXkIfa=L4R!lT!K8cm&c&=ZE@iOChw}~a9 z)2i9NTx|LDb>ZiSzN+h+sE6#4j!PmHDurt~92A$7%rTj<_PCC4Vt*tb_Aw4n>6$VA zt_!8sbUA?k&W`Y)gU22eEao7v4EKw8x|-$PBHxyZXg%%Zc{4f#npMW!nN3|EHV=b; z)zTY#FN+}0y>bYCDW_n_=GQU`;F3S}dYpRZ+JCz~91IbebA8w!iub+i!;{Cbt+vbe zmZK8&*;++}Acmt1OciNT=kYKR946;3i5)?n9ezWY-A^nQN~KIWEMP|*E4)(DN=390 z2Njcg-fh(^&PsdH4dEbKyX}UsRmZ$<2;1N*r2a!fC}&6DjF)Bzsw1-zTZOoIZ{>!+ z5x-EW!{WND226x^5O1vAp4*~ClE}bC0j}qH7Z!O|;AJhgB&v~Tgk!8LwKKX)H;5n1 zWKd5Vmm+bNjpsr{WZl&?oiD!3*3DJ~Td9-h{yi}|NGYaJTgRYL8C?=b25C;UqaXF1P!4q7<&ej< z2wpsddx49z-#DYT$sT!A*k`CdffYH-Q}Dy$I%Gf32QboFv|qm|Y-uZU;Q%uw_Z7Q& zR74xdf@0obAH9hq4=e8IeCej}q#&4ohaF|vi=MS-+HlOE&7~3HOEiHT(lRUqn4o)E zNAZGAMDrKe`)%03*7{Q${s<)e`rL5nC)wN34m+6$`=6Kuu~r@vSgS;M(z0Zho3yAD zA1I8zb2n==72U7Lp{e(cJ!x*(Z2vwt9CcRV`j05SM5ZD_54OWCGVm9*juJU$yjC#M z4G*lyOl96%CsPk=LL3&cDz)wgKR6zH<*jfI;%YKrsD0p8pchBhL?goYpk@`1tYncm z++B@+PEXg^OlM8&DH0_l?SWW|&I$M81Hy4rVr_LvRf(kj!r(;)b{hO&7BcES(Fb~@ z3xogqZDH$~9`==dC9>oI<|;@-vr41Bd8$kEp-v?{Oce!k3prg{oL*c=MEmJO`}S>N z_T*Q|jfL_+Lij6%Qcxp=@ZS`tS-#H~r)lD6#px#&+H-CXFG`HFFW!z@_Ga5KFFd$! zVFsD%v22r3y~IQNFZ03&n`enqw?eq}5YiB*3wL!6ChY(1@H+#`AVP?tit9BA$tDj; z3HIE-zQAt&Hm;y$w*MXBfuP^iJHj>||K%SG{Nq{w*m_4eqF=l(1foN3Ti6c5xoyEl z_k=_3S>Fj8%9enk`0&|p-xFSH-~UcnPXnp>VM`U0p@tJ`c*14c|83HToFU&y5V@rUXM`{bXEao~Lft70<;-hO*GE3@Z``%sQ zupH}&`zm^9%2}g}o2pb(wLLdg+0_(Y7QQLp`E;2s6WL|=k1Xmp(oa`4W%+7~dJHW? z4iT^*`4W+k07a8uSs3oeV(4`@-mPmF*fDp9M`Y&-&gsZMgm7yU+2MMwOQgO{pk$EX z`nx%ib(fuVPxy&aAthO}?g_s~*64dV+wrn}{ob&#Oxj$%s$LZSm{(6O3cps>48fQS zM=>(>8ykH$Y@CwHPdsy&WJqbq6->pn%qVDLnq8%^u@c54jl8d8<%X@CONP?Tk^_^{ zEjHUbzl%C3se1>?Gqs_@5;W<$pYmu996OYBbOIhifgRu>a@-U>iTV{L2FL^sBBHcx zl?ZntxDp)8Sjy-+*x{wh0kyn1N8|~SUl2^>7sg-rH0v^=Di9B>4L1H?15L_acdDtjM|?j#{ERZGlRz8Fg#6H0QAIZ8VM0XFIRPL-i=K7SMV%KfRVx^P zmYa_+<6IJv_cVML7_-(MaGJ?fOUP$BU=lL5HnEtKNwq%sWt=AtEq}Ky3S~_QimM=+ z4R1pLHv+ZN5jJZSKJ|crDCUZ^sQ9yGT^L1g1i~!-BdFg528bExp@+e#mV7R)VstL< zH44Aci5&50iCleNMuD%v5{D;_`jr;p2?|=_NpFzVMZS*lBt{VK*P%f+Tw<7(AnftO zBS>%koSyF8lC6(Qj>CYE4|!ehG!~c?j&gTvI`yP(X}|$k;X#3&;$6BZqheQaA{)$u zv8Q>sfMi6*6;z<93Q$|70JXI|2v8fuB(`*L2^j>am3jw$K)Q@fJs^_)CR?LfL-mn! ziVvY8sO&2eu$97)!Wu zyl%F}KJtTb|8d-Is~`=o1L%(FR6IlE5Iz>DYG(Xv*B=_R1Md%qkJZfLGM%rL0mt=+ zlJA`PUa)fUJoK26I2tU9F(E;%KtxnJj|2q4L$Qb<1A)@3>LC*X zmQN!$*h3~&kMj2z$_Za{jw%c0>u9jRtrnKLa~d-`VG8+lT@z9`zo!nu4QcccGCe|k zQJoAQcq(-?2mzkPc06|nRhP*Q0s&V@`J7X<$G4DCji@f9%<0#o_0O>jWuo?9zy`VV z{fqOL?Ez8fVQW`QDMk8BVN8f;3Q{^eXvGjlrs5HE%e(mb6vDCyF+bX-rGAW}oN5k+ zq+knbzgS%k7(980sdMaIBFRnhCFSikc>PaxS@p$PQ=q|X-(FGTn-beouBp?O!Aw>< z+;Y9h3?N&^i!Dg5H6l^zT#b%5_UN-R^WtBA7)}bF{DYmbENskGGiF>j zlb)jI$5JjFoqQ>?#$BWMI!fs;R3u8GOf0M3dV*mIVVAgHI#>h2EQ#PiB{FjF=FoJN zO6#gaUz&^W;?mV1E~PPYPQG+dzKQB+<(rSYN(ny>09oQfYApv$J~d6bhcO3B$?OE) z>Y*H_(*0iq1Y?)r52s=<@7x8`HL7G1!5|nwGPRU%#CB(jNBLo6w|Mqy6fS!iM0jKiY5o2nIcA?|Ut5v`_vh+;~({ z@j4Sa1v%-U;KCjNkZ{LjdISP2-8p=*?T?!FI{U$o!_fzH1Kw`Fg%0W4Z@X{1qs)f^ zbC3t->NoQUv()|S0hYr69i;_JUs|yArMts2<8kuC5a!742s3Oi5GEe)f_)$FP22M0 z-TtnA?S8zzw8ra8|34b?qKvZCjY#9tpmP6vZ`2UtEK9#s49K{|E&Cxr5Xrue(F6b%R%yHrzhK^*YhHWBWS|N=$UT%N)SlBOE`KHZ05soIr z&8MCS2lw23o}v~vpP9Jf1HX!bXqEf5it%wO%&yroZH&zkRcQ?PBn8^S-nj{N_DxKA!g<7dM}oxahTf z%N_35E?SP~-IrF&9k1(t%?c!B~?!0Okuj-ghdwSo#j={aEc+i=NtFOwBda3)hdvN>G8uikvdKz{2 zenXAyHO~;^D5faCeFloM^zHoo&U3$Z(O||SwlA#)=e@n>^UFffvii#(x)C(j{KBpI z=I6LyyKml?R`YYV?s@Yuq#t^vsQJvqj@R=oZ*z-l7cIy5{Cf9m7tO~j+Lu=I>o@Ir^YOsf7B`=nxc<-imRGu8yJ$HcxG$}iSN?g= zTaE|*LUGISz-M2b$M7w?!|-_EzOz+dQo?Y?z;!ss{b!RUQyHNRmmMjtQvH;S9jOxzNSd_lA> z7WsPQUg9P1ORME|f8TSs$1QK|-tz4C^E1B1ExcWTJZ{;SR?A!dy5}v&%k915mit+^ z+E*5c&EnnRd%W6xX*IuiFYrA^xb5AWcL=v=b{^q6+^=1XK1MiSTFrON-gAVDo4;&R z(e4)G`^EzAwt9EGTim=at>#zn1@9I&Kf8zKH@}*n`?c=Z?nm!StNFFB?)luu>Va#! zH=kNBS!sK|`Hk+^E}D08KVpI_qvkhm-|Ob*?%ez#o4%Ew`!(*@?wj|e)%+T};W7MB z_e4^Q5r0AV)*a$^xXn%S%C=Yu(Bq1a5#N_q>)W>N`QT&j`R;Db=f$-(1&L+Z?%1m# zp4R%(>cFzSV6XC|zFP-kQeW8U7P?=%fPS9TyE1Bi;ha5Rc`?O%u(Z~Wi^uF_*pOtVDwub+%j_hp6rW)| zZ?H3d7}ndVe+&l(_ha$-W7xcx79TFMkTv9{ScXhS+nrsc2L+%kK9rVj%$JsK%$F`! z0PeBHC)HhnKeWmw-U{opc_Yt?M0YC>lw%{dk!V>D!~8HUXR9CNmRN30M(bj^wMUB& zr8P)jT7&eZiwD`>zK2$dy&R;82l?1O46@k|a%sGWB%^up9@66=DXl^J(i)^M{Sgi_ zx2u`N5vaPzD*0iP7msUktV{$~V`bv*#zpDFkkm9VU%dOk_RPc-+v~pkTG&_i)cZdO z2UK8m#sb-tP2P*$E`bJjMK9Axy!WtXC>Az+eZ4YwSJ?Zso7e_Bu-25?y3OH!d;aNj z`+yTeJx*+o^Xzo4(!vQ}TA=f#yMu1u5P#T*tZsHEx4M754}(PV6bai_ zFj{ZemC;&*baE<6eOE?<^rb(JLFQNYx_uZVd%p&`&grpbwO$cxw0BwsMTS;iT7&eZ zKaN3iV9?Fv`h6JW2tUXTv4RiNe5~N>agdZ2y86-@q%Zw(3=($24f0R>Fi6-}&18p+ zP|p8g+Z+0|i#6$(U93^Avg|p?%uxLB_bWJT~zW^FB85^|)YST=JzgNMHKn7$o*dHzqf86T@QPnjYz%19*f2$rTbNt#H5oQGhRVz{-YGvdPYC0+ZNtJwzT<4;O=K zYiLF}J;ZK7wPD{twJkQFvJb`v)ZK#07Z<2}@qZLl%VSWTosB)M*OZ!1*l#Dz;yp&u zJn#Bw4^{0sq9GC~+JdvLE1xaVc#;jzt*;!O~LGAKL>Wd5VzW6^1`KSMA zPp&Wps&I9Md3}#To=4MXih=cV<(>eGBS!lItZlIo0yK?{5W7dy*a`ufx?le&u%7j} zWjYdhJUzbJytBvf$}3%d{*P6Y$I*3NU?2D4gn5KoP z5Pu;C)uIB#Z%B1Pe130Jm+r3B$UEldar4D4AeGwJdzc`^uceDrYrXTs~czvgSWF{^t_(06voexAj9lo?W zFn1>(2z6j!PgvZ*AtN6lw81{!Xwu$3Ir2znUUUY^Z5SGRG*IeA8|N)c{n>2}*G-$i z*|7u%ak;>G>oWVPCbP5Ma%;hEsnhtGq`kJuWCzaugEXIG_?RP9?H5nr((Xxl9Reo_ z?c@DS|A|h4cLrq^yI)+Is8hRB^JmdGWjTb?lWsb~Xr(K|X=jzTy<1JQydt7zGb+|m zro2@Ve_Z?37Bg^&jF7nPPT;BuPC)I{AKx4MlYXYfzSL~W4qffEi0aN#_iGp3aabBg zzO=eS={@fbYen6;b2r_|9=g%F2dO8k-LGBrBnFHxt)5VN&wIiZ^6JSwyXi@b{Y8r@ zo4DEu_YN@b*Dku_Q~`7%Rs{fN^qH>O^?JSKdU-08 zMC(Wh3HehvM9Hb->MRC)6=Z#6h$iHJWdnOxf77JkNfS#rY_9XZoH8dIP)Wr>B^iFP z?Q(00LP?#=qqm$9UE#CzI5eRC2F6c04^1P_i9hnCFXv6bZ6e64_; zoKpu5OA_4dW=+LqY+sR>NVy4(TSEq&(nBi6;?oAxVv1pD_ z*F^J)-_ZsjW@Ad(k1WjL9emdZI1f{3fj|#1Jl&>L?{wQO8Pl30uO!4OWR_@zK4e2L0gYf_-Vg_3 z=VhdH9odQ0r7rdcA=))_*UT=bitiYP8VV}Xy$=JW!izXtM?8~;-~{eH7LYv z*r6cDM>u44RU-f4&S|d6C@$b4vk>9I$B1=d1X6x1sD$E9C@z5lP7qXFab?|z6po<{ z)Z&pQI0lba%_y;;Gp%}z#JI;}aMq2(hknp5pUDwTZFFLGg7=ke1a9^3nL>rn0uUEE zAe&5oVmmYnlrB6*BPl#;6pMvp=Dy6Cv_#m33Bj2FGod+fL3n#9vV#i};bw@KWHX42 z!CN0fg^j3q*|``CmC+n}rWnP{NH6t;W!H<9Reo$u2{>GCFP&MF&gF|01%RmYq0zxd zVO5=Qpqd9=E$7i+{jbw7z|bU%M`#4V^rs2PH)sXr<33c6D&g)f#eHxqjDTvPTVRU& z5KuIE8og76uwBBTqQDQ@FPA42D}fbI*`oN!YKtWoE&0w93g57nM;yN4A%4A4SyH9= zJ#Fb0`-vfDNbVs*$Mq3KO+Z}!P@3+e4u*QP5n3C@8O2JdWJd%M zh_fJvGLA1zEUDGnr%&#}8|@p~8&da%nXwe(6Bolq!B{hHEGAn~O%%f!fPAcd;O?3_ z;O2-2l`tvVg|cJQ6E4q=o1D8`p%Z^o(R|9dsmv*J)4-6&{hxcI@FGg4tDy+fp>B#% z(*ku$2LfnWn%{(AAe^F$sZ2mNuAuv7dfdz`)i~T6OVexCCmV(;_6J=|sxEFWOvsx~ z_dhb9)EZTv&#Nr_?oczZQUr`*lvcXYp0}j58vJH>!bETY5|!yy#f)(&V2P{P|8ixj z-F!lcsN3~e(P?2$T&NImOonk6pbqr$I1Q44NLmnzx5uoAu0vsbP$1w9e%P-}uT9!D zvue!5F!et~&tMg5eh7XIf`|%-Ts5A$vm9=Pd{&*P9uwyr2#LZiw6K$gm_bM1N|3%j z#OToMvB&jhz6mP$s6&gkC=_HtkdZ{g0Z0U1%f~e*x?+K$Aq3>XZDwdL$yB);NCBlI zKv}JIE>X>8SmKHt=5~u}w~RAJ{nR-)b}bVZ!Y?RF&Tw6by#z96g|j=xx)(&CnxR6F{h1 zw`;SJ5V3+KqeYqM8XVl6nE6l&T$x-o>!>#s@ta!$d_WU| zFeP0kn;%o_JKsla;}|NyaygO*sWvb``!b7OF`X(|^+JhknYMnS(&hi@_6Ne}=s{p- zcQ=fSYQ_Gag9V0kfald7D*6R1lBvHD!Q1WI8)D=^3n%Yp3BIXS!O}T1n^YE?5M5E6nUDy0 z{D|UES(OwPTq1VisODd0d^!wQL(r*m?6wC%aJJHLqQKBoh=A6 z6U3y6S>>bj^lXFY0+m^v73yWda$N>MhJlG}QC0vE&W2Ihc_hn^ZRx|U1&NE&iDQk& z5-wV{e;8?wCI;=uQ6|H7O0$GpW>p-^v~JVIr^jF5!ic(ac#P|p$@Xkbwq-&i~iHdBfLocYE-{6`?DU(j>`Dn`&hJm z1D20=oGC+KXBv|Z?O#Tj#^y@cb#ynG1QcxSRJZ4-=Uj`>e}8kxDQxfQq3JQ{v3?IC zcHjZgh35%|_ht{A!DhkkHM#xL%Vy2)n7^VuryYm&P@bu#x@6j2Frb@?A#Gw78~MU6 z+8>bC<##o9BIQmS2_}}Dq~Y1?Urja!p37N~&`=`rTOy$v~Qm;U6TSNuNYSP&d z>!w8)&&YD?S_KH87cl?R*=NC8wpq@BK;Xn=@m*-|A8iJfX)AzVu*Z)<6CaE*2R16| zFOx|~vpDD$ql`;@K3C}^F_P23arR=O3`Q*M>9CvPI{X+jNw<9rC96?mW(I}DV?BO~ zyU5nf$V!w0+jg1~O)FF4q%k7-QcBw|>j@+WLWD-QBM&f{J_PwyqH8J=nu>-TOP38` zI@Bqc{xyn3SXc$L8aImH5-e>Fqr;mW9MEGb%K zi%Cy_w@h-UaP#c!!IM8InK_x|Xb&B0D*I{tn)iGFFtFFH*z5%R&tuJg+>IXdmaM|E z8Cuv`L4mJ4XDPr{E9oG&E9P=SF#!N6TgBy!ovKyjsfMdP(@)z4j4rn$&*UYvzQKjK z>nDWELiV-#SztoC`dqf37DT3%eJkB>TKeF7qYp}0h>n+opM(~0jkLPuvK$hWr&|da ztF_F+)ND8&LL6v6H#8AGZ3!j9e-^R-Wu~VG@k=$Xd_z3QE|NJag0TO^^-6hzu@tk9t1AKD4veB3?^TZ5i_I)v0 ziv*1z1ZOI{ZF_JSeRNY!7PUk*bI>4>rp|5~Z_+twDj-EX48u$yMY^qI2o)4*PbLLj zDAu5zmJqNd*)pd#38E^nm!g6TTF3G~cG znM^0d2Du9xHA+l2nl-o!n95v*7)>#1z0+rRgVXONRFFlH3KMVqMQH-$0XU$WLn6B z5cQ`^z+@<$qQ4-Spfc2RzX}%Vpw-*Oi5tXQs?0--O5KnIb~gcm_U|C)rm&Z%_r-I- zurxnvQByG}-)s;!n#ecXZR*m4;;DeXxPdjsy^yv{y>V0Frq?CQ5tYwmvK91F-2=_s zKk?ybaFNB5gW&_+-MUQ9>;!UFE-ui^b-di+o|mc`K|g^`n8y;}f*z1LkuB@OKnFqy zxW?7UxEz?>-Rz09+wx4Bs{*7CCEgvnI112bG){C<<|fkie1Zmw(`if9F=ucv|qZvYG}#V;P~%Wgr;87>7f1^GVPNhf{sSU zrFx|sJ$AYpr%B9#9%x)BRKt^DyIn^$Oey9R(Yu#@{DPYL95{0*U<7wiJ4x$;6snCI zc(6LfK^f0MDWobPdFd%y3B~izB*gXjy&}s{Ts6qCz8Zf8l}4y(q=CX4e`A#!`?N!I z#jiv_lppT!1+0{0s4}T5%XDWI(gPbj1WsyCbWvSu&!`@T2I!=oLn4F8_EI@ z;YbcTzQfnWNHS=zk%XYs4oL>Njj|X=;DH^Er~~Sr!;uVwAk1%!CJw>T7c#s&nsB#J zcQgThyFn9Z5ei1I&9$)`G>NO}0ZsA^hzD`#5ERhFzslzq&?Nq1Cp2NYbqk1Y;?S>= z@x-EmAvGAX$|DUO<FA8G4E6i+`A;Z7d~PdGr)>mYL)=EEKMEI0aV!QX zEByvS)G#(YVHpe1$V|ni!BbEZT(gZX`mJ8DD7Z9CFR&1Z$gtoAVL zQk-C#gVNSS?ZGtWTVozzw;f@Que;`Z#1Ia2V?a%`F_0GaW&4>)=0s%J1R@iB%KRNl z7~LtrOoiQ!H&=4XAN_b>7&{YL&h5&nHH!v9byr{17mkPJu>N2d$}prq#(^DxGKwO z9tX~FB=4WqmGY<*LVp4I#0Z}jmkcP$OqX7${6zFsaYE>kqiSW?`STO4SnVD9_ z?o5d&eKdb6rn3)U;P$ch#IZGj-?jDLwoEo75A1~uHe*!DPk(X@9DPkFj;dGGJ_@l> zd|J`lUGXel5QINIPq%ThnL+b5d? zDm>5z1EC2=njzeEapsX`D36&(n(v(aFt?*Z3S@>$0%x?G>lKneO!*h7{0pqHgNyP( zNj|{Ptp-`l)8H~9t}C@OK54$3xXf<&q`A3*i173e?#5nnlsTYM%!vbcnSJOeGop-8 z^nfy9s}>|$Ew^}oDsj6#12tdnb=)!NR0mpXrvS+-?Ih8Na5xdCMjJNE;--LT{WJmu z_a=Rr$~m=^W0?BYe`n3Qa~hU=;VT1(qeQ%rNBk3D9JNlz3QP@zEhy@9$$ zWOFM#g~$}bqNrR$S{k{kSnYysL00Rey>p5gQm#cny3Rf~#q_15BqUe~XW~~F{a#)@ zkA*eeYdT`ozy(2T3#-`QMu~DBv4gpR!n#=dNqg9_X7tDb(Y<;23cL(?73ZX1F4IJ> zN(f49qps)Ncx8`;5IY;W?q2L;pE#Bq<$tV8R4BbM05;B5$i*609S+94+9Winc31qu z0SD<3V(CV(2eG89s#_gt(Og6u3P>R(k-q9Eeq09bYa!(VSI# zEBHka!_;?-NX`J;e3BWNo2yK&#!7X)6~=DSwN%A7YSe_t*@S&BXEKq8fqzsYQcC!D z#BN+4xxU01{xOAuIP9lx1m)7Y znkAb~k8*dr5<=dg1v{6zznkkle6PUr`zGrP7nJ^BUvKp8A676dT?hx35&%Cp1&t4N zaRZ3<;DLU9C#wFh47P`{R^$hpvd^Aunxh|Az_z&?vhcpseNkvCi0#e=N?a)%me5%( zU#`(ZF5m{K25&EluW@dG_}L*-&A5Tj+*NS3k+L*eS)5*em%VtZ`Cf0`3)3qZhG7E3 zB?E4@V?Sla^wHfg-uw(@lOI#F{f|#!g zxbA|=x;ZsDsw5Q|?V0==9;OZon<&N2fA`rnr%3_U5}|)wX86mWq+0EDpElJe z<3g7DrhJUtmt0!y*accri|}?3$HMoBr~do6Lt_2-&@-15V{f&uecH5+f-nfz$*T4q zPhs>otjwYqtk`mGU=*2Hf~yDs9eXOfhOV<^YHD=_&c(xPcf9jvHmb0rYWgx%gh}Y_ z=tM`z#VTA`bDC*r;dUR%e(0G*Fu3DMyGJyS>8|v*+{i!()#oNqa@;L9m3H*6E7IfR zJg8^kmK%NE#QxXUFN{(ahGr(KI$+azZGV26X*?6h2PQ)#)YD;JyK8N-wSsm)Ed^-# z+it{VsHXyrF23PXUU#Fd^r~pxbUEO7?Xn7B(xaeV*(Ky`>WHYaE&1V&EcbLCC!BpANVC%kH9Cj&VZ% zL)@+R((W_YK3NjISrW~a19+c#wz)3-ypgi4Hg%V~mHZra-u*h4&bQHb zTlEFgFY$&Q`UUgJ#PfFg7tDY0>8s~(>6iH;2Ri23zF#yalrCNdY@W2|e$liCmpyJ@ z`=a?t;#zypznG`^==^ic*ZoJD=GHG^N@L3c6~u)eJS|%LcwsY2uq8&TNyk>X1fCnw z%HlNFIW8|w;{mp`IE^^BxH!#5zpywxPYL_uFPRJfUw5MOyZ?%88utRC6^)t}UH(M( zp|=;O8Tz*3p)m9<#c77VsW{EhHx#GWbtRxED}yYT<+j-q&ovc^nfCN^&5v@|hD^KI z2KGD9^053mD*PDl7nJU@otC=PU5R*taK>GyIF*mhg`&MdRh03JNkZfeS{rR$QD8ru zBlKp{g-NF88%ehmGU)pH;sR?|*n9rn{7YR|2WcV^W#~?4>ol_>(SYpKGrrHP(PAZB zBN1E5py!vKXKo(nvRJH9g?2-k;ke<}ND5;qEV+ zv)tW86m)aA)VJ6!XE;RiU&)8`fn(tO_cosbZdS^5Uy)QCH z)N8?N`#J-0n8%q>Dz)8y^*>CLC|@us`u&HMFQ@#LOH5NQ%13|vu+l+Xda^*lhL*Zi zs!eHSVD8S%@ZicvEmC#MZK&+WJG_Fn=#_o+BGV5MOIttZ2z9|G8)Ri_d*`1oGG{0K z;QyufGu#meCU8Ac$>hq(C8=lZif@=}0msSTG-HSTuRQ32Nx>!jAOE8gX`31Q4zNo6 z+P?ZtvtQ4E;pI7(nEiT!0Y1}0YswDNlrgLM?Oh_~=<=(qduqV=a72^5X(U+P#64pLi;m8kZ<)o3#*QaSxNR)W<(UCHPPWWTdmVPoY}1#~|7o_F)r7MwyA$Rz zJq)4)<}PY_z|OqVOl=Zu%2M}H2C;as6KACx>#%>m(u}HpOAcs(yN>BCJNPQr!&~-i zSDAlHEVVCQWo}_q7hG*V5v<%~AH3QOPkh0yzuIJi4eL8UxZ0E_J~h9N-k}%ApcB1Y z63e14v)yO14tJ95r*uxtlemrac+F{PGbS`l)#Xx7q_2y(0%#UAh_Gi>v zuE#KW+e_}0mwjUqC-RrvYL2yYZZJ2T=!Sa+oO5aPRDQHBZ>q~1Qw)G96k>yP<1ckO zfbQe(&Ae^0_5}+rb=WNy`nK6N&oyVK z+0KnLAh0HmGfA6*w;>!Y0grE;3z9!z*UhD#BwkNQA*z`Pe3@|-+ zp83z-3rd~XHoOESBj=e?YwVVJ=F@R@sj~T_>{GvOh6cY|-}#Mi)8omm$88cJqrUn6 z3enTbDnfio)@*@p-kpqHn09;SJ!XLY{T*f|UHP}~m;=DJTfbw5mEG>J?aVH0yX78} zw3FtWYYMAQ&9a<)JFY9NI%VRIP}KOv(EUEZYW zMT5qp*4>^PgB&{4g(-sh`3$o2*?Y`ciE1@jSZL!Hk@c{>X_4#FQ;Q78-d^f_ZIP)- zoZ{MAg!&TQ;j99FYQE?D%Kz}LvQ+SLcgFV{G1?L6yy=CrVP=af&D zxc{~skxuLv&hG47c^~^qqO)_$56oNxI$!xiGoHs|KQxEqPA+2f4c8ZzfgicwE#e+_ z?@ZjoLbp5Y;Y&?(*MxL3A>|21e(sNuKJK?~{m7hh*xf;TBtK?j97%sEdxWhHktP9f)}7wnIIY>uc^ znKaA_dLC%>TpM4dg?`z23X{;Lz!^L_TdPScoJXMfshZeoY}>@su6Y1-dh z?btfi2r6>*C-tWH{9?=Q8~Fu~p)(SPR-9h`0&{;5Um&I|*6*$SK`7j`%$(KmFk|z3 zqb_I+oagq^&d)t$Mki?f>W9s_=61|t_A3j`csueZrnc%vSB@3IK7RC1%wdj@iXrVH zp9s#w!}5dB9B@`{i(T*&=D5Q?_Y*Ul$LY(>Ipy~fD{BdK=G_UM$A2Bzd1)oLblcWsep6LwW-J@<6uK%on zO>?JXiaJ`db4TBJ)ZBjH)f_V1a~Pm3eZByptL@k`Gn^QNFdpst=uBhofoc&Aoj6ndi)>*~q^4oEb*y`RB~Rr^R2PyolEN-@4E} zS{dh~M3>}#(S_Mi$B$jUWT*?!obck}8PW2Gv0-IHuicMx>_7j)9MGRCoOeyMTEFnR zk(;XPCx7gHzc5F9CT>N#(n9kkJvLv~)jXDr9h*l{EiTnH&!{J_F=tlg8>M;s-8G14 z57}R>F%R*$=9lJ6jQ{Oly3~Eon{Sj-Se+XED>Esv+J5y{<`b!W-(>A5jn*u;kN(Qc z$*ER0^ztm1Zut@rPKFk3&>R0?R!~Ml!H>t|63u8_Qy>6tiW4PlxIpm4mVBmjd>}Ft z@1qX}>bqq?)&p>fe#xUM$}QGU>8+ww{BqD&VvQ0j`J;rMg*WSzSRKF7vrue<5^Li( zdKQXpQeu7lM$baA+!m!a#;^1&l-s7n=J<`Cg<|bLA+a@nqi3PmY`xhYztOW$Y*z7` z4keT`A;<9M6jCJSDxn+={HEf>d?l2lH}i@UiR>lcE3vbpbu{wUEXQ9{zCDz7o^vo5?ZPKgt@hd$G z<+doXF@B?Gq1ZMhHpg%DEEH=O+HH;B=vgQ>TW_|0j%vrue_5)0j%Q~ZxYxn+8_*uC=4xLirJLT{GFZ}cn_ zTVDKT-E!No&WssCURvXT(+;LZZJ2SQjVg!Y%V~*GG%kMFPFrVAcC=#Ca{Jgi(*iMl zah*AgN7D=D(k~W$;8wkS44L>s-Lf}FOF{G4RwvOnOUDX1QP)aWG1sFaIzSKJe*qG{ z+MfIyGo=^xLTZjiZ^`5@w|D;rGWfcE`Zwm_*45H)#x18yaX3;(M2PrfTV6DyrLMic&`m(8NmjwhYn=Z7yd-Ot-CJbF8eQq&l$|Ir`Y=Qf!m2i~%> zNZ*fcZi?i%qwP1;`=u7d!)I?Z1eA3 z`~UfSb8YDo*M4W!Mw18!({i2qit z3#ls=kectRPQ9Qr zU;eYXrgV*a)0x<8HUw2(7msfvtkUM!&D{;xJRtFZliV4+uWT~<-4E>icTK(5zpV0# zpbdG=zy`bKjc)pvH{URKm#dbjA$5zrV+%aw1NPA^Ox6STjVCMpW|`;n@(l; z+c)8o=GydI=IppToY$p0SHFd~B+Bo%kk&izm$W`2@wv_u-bSY=69S4p*KKD^s7c*u z|6{8;b42I;>i$Y~AJQY!{|fykB7f@9vP>dfUR{sig3R){&iA*P0r{FL)S|1Yf|^FY zW6o*aT}^iJJNOiS&OY^y`Dw#~e-vVWe%CBypdH)HfAT1Q&-{Ctw|X|+@-~um$9pIQ z@3!f;%^EE{R`$ndi-CCVyR{KEsD%!;`J;6Nw}$rt9nxLz8`Ndyp)ja`R8)m4uaGc(@3! zyulDDOp}{${b|=akb$o_E&E<^dhM;9Yl7sM1h%4tN!|t==9y&E{W0w}E-@DnKR83<~lqQd;{J_zgMTwfUy{H@g1n` z-T@l?VR3~t`2FHE4c=9pzWtU?M)$9Y;BTe&o{Hq$7B@msurOK#Z7z*!qo43WG${3! z{in+0V<13tRdSl9^YW_X4F~yN^!L4(8&4ChUTS}u_XLx-P4r%It8d<-VXBhOhpUq< ziE;`@!%}Y3WB&S+`VKSIKx8$^Qs26+R(5 z>vkG`4DefyP6QO*6UwN#PK;ML{n`I$PM$tyhuOP^bODJkFC?n_Xg8~)YP-ET`Hqlc zYro`KF=S3}Np92>AKscgETMP&7-kprPfqY)XtHniPacujU=J9O{CYf*4-82DnAtgZ zVDhuU)>6B2VDcIYoRUudVk(%%>FFfiKq&?>5ENr-+Db~~+NIDs(O;SAxRX-7MsF3T zLBZFG)34069KXG;3-i96^_X|OJ*;oCzVni7aztUe9~+b`A5oYVdHNM#$oL24L5mBW z$B8!wCF@()qLx&c70w5v@zaKZD^%#z?`v&laIz8fJ7jQjkjMW1-Le07Lz18OSaMU0 zEcUgb$=W{PcoH1%9bGQG+^_pbvxg-MOGXZtg(YK0w^^)CjD}Bw8Dj9l43zT5eJMCQN5ge4jhp@ zj%MGSfid-l5y?7!-!mdPY?zegVFXuzA()+6l@$O=Dv#NnTSp|nmgriQGW5$otO=tn z=Z;HL8#*r=nJjm>HD^@vyD<(;+&}q0TGDl+lQZM2+earyo+eU-dI6K~@UY46C(!Fv zOxdUs`I*scuxJJ80;+>W%Zk%r(URiyqML2&nB=F$cg+}+oFycGcTDn2egSlT;eh14 zL_Os_Pl#Ll(HO3V)MQ_e8PAo4@RE;kx_SxdZ zce@fN7MeI_LQ(NsiW7e*PK-OKsMyTn#Pe~2QH-~v4^IAnw7m(O6xF%^-BsOH)jbO| zFayKP0M#wvuoFQ++$h{|#i%hRCW?tGLtIeNxHaymsG#T}1{JSH)Tl@_HtrCYkSJa5Rs_UAeCSlD|edLsr@5m|%$HRO-R za=OX3C}%eJRyyv-^UcGPyw2v2=RcS#^ae?m!ql)dUec2ze!BG%x38IhiR+mIw_pdJ zW#(<+z2m%UPTJC2rca;P%ImM|j$3)>)I68}ww3n-TX&dgXwwgeY~vlS>mRo9`ZwCP z(h@m{i#Pw?#ydzq@oFndvXAGNPnt~7xr(lgyr*bw))enK9?QFK>+Rz>ua>Xb&YNL> z@418b7|(y%!Fx&N_e}*r^&RES=7s~k2DA6h-fMmgYUbrm$oBVk@n-e>ST6lF!&K8t z|GA6jd}}@q;6PqxS{q3dbhG0uX{l_FeYa$9x_>)lH}CAE`)%!d4*|};2594tgr5wD zHzTW@Yu4=+Pts3z_r7i4ta;;~dL!Ld59~K)%~pGPGt73=ypaxpN7KCi{cZboauMI) z3e7p)&6s!UX_&(-P_C9Crzt4=R4lBecr^| zG3m$@XWtmMj@}1eW4^gyAFth~G3LxH+sEtMq=xaNL~u{q3>q@#qCLGq=EHrw!z!;H z@?CE$mi*f9dcRLMp6xacXc!1MMUDBh%}M)t_i8XJ&+?kf(|+KcBG_2-Ljbq&LZ`8B zLqEOPCx4+?eSo)6FYZ6xyG7Stv+J768y)C1InMI(#2_M+bl~G zraHVamzO{JvG=%B>B4Mc(v-g(^7E%D${Oe9{t*V=Gx;wD^>zUqi*Ll+%dZahL_nY$L z%Hb>TB7?Yv+nALVW9ew;RE9feYwDp-Vm<)@GGRyn+L*(`5} ze!O>IT$9dzN*UX=f^S06l?X$i8T3$=r zjaJxLkuM%FuyKM~EO6W~+dEF5hsOg8i_DhC!wtS^4n7{HY>{zJ@LF004Y(2?Tl8c` z6IkHO5QE~l6TC@aha*n#uE8~`_fJ_TFx12oz28ylp5)!Gnpd3UJ;D;4d9r8pYx}9* z!~FWnsWkMeX()L!d8vG2$=lxLt(B*F59zJebGg21)}9L!^5ZkT#j40T%R*I|wYwC6 zvOku8a*lUX_YZEXc~=nFT0Y`@Z+7Ja^XWYArpEcmTB5Wv6wNokz5w3$P4njqyf-nA z{PsfTaGm+&LfGS1%@Y@SeOd6=FY?aix1;CV-+nQl59XUS^S!@Oc;^CJ`1S&Cu^fGT zc{pWtX-JZ|30|+h*qi3`{qzY0%#P^HCo#4t78y7Zl==(31@buaN2NMqk258ZUb+x& zVY&JHLT|V`=S?&4Qt!Lo`I*)R&-~>wZ%o6wbgN7n)`Qvn`ciK$UD^6F+m%_Dd57}! zr}(Ld@xI^n+ZA0;^;A(0_tZWk|B%^ik#|zpTdys$-$Xz2CiLem@SalPMVHg@XzS>? zxc}t^KlAQ%!H~NwhNC^LJa@6zOCHjfUjbMwH_u$b60a|Reua0cQ~w*>oh`5Tif7(f z;*Bo<`YP{Rj`JJy`V#M_gmoTxwRbY^v46SR`x$_D!hd;xw_K6M-}%4$VSD~%{OOgO z4OLT}?xwSP?c%ByT;tuwH``z9joK6>AnyR+bm3hU-IJcqtUh@}8_55USXWL-Txs=c zORoh$7MX#+@P?|QUoeS_%uj#8R$pW;|AluV`lIISyqETW`xfa(a3CQrf%s5eU$#ZC zcrFjPlGOORoM6j{pROr8inqu#7kzrsN=!7CEOj~GEGY*A%SSC`Gf71Q$C`;1D{R0F zij|=^c(-NWqdimt0sv(P_)QqWh0qDjnpp z**v-2>!Vj+U+zt=`7QdDH!iDnlU_&D)Hi20%}OyoKmQf5_mpYA%^Rb2zs-9@xWn=; zho2AcGVXS-1wh{Qb_THA%)8y23|U%pJF~3!gnpO)@D8u~V2&$;jNUZG72aQx7h22h zch=J4E$_1U&SHHJ#7rk1zKhy#HU8b+Px?bWi0vfiuu4S4zBE8Y=G~31;Z3vaJ>GbT z$Z7X@yYRH;9`DMpuu_(tSa`3OR~JNG%)R$|b?$3v^VVHnTivZn+E*VE$e+}g~r`_kZgb4{a!O9EWeury-$udWNmlb&IK5q~h^PT&=8zxI_Hm9$f zFQrcZ?!C6FoWv$GqSvl8A3xv?Z&rC%wVSBgC0CU^l(PyoXoi1 zBg$3df-`HkaLZ;diV;i)kys(HJ?r8XZ)P zYUd8MCAQaS}~11O@|k4`|%SjYheIt$k;A@xBO!9*(WH0L!uc z63rCRS{?FqA}+yZyjRpGVTgppS6{^h!E;mf*t1dsQP05n361icaHcL-6FORP4N6uWF z+(M?w>tv2HyR}(QZ@g9gjF<8q7mn}EM~EQWG&=K9Q27D{?kwak8W-JKDWHKwo81uy z^kYJ&vo8vLYr)7Su5)G!&8#T#uH-e>s57@N!bF)q8Hke@6*o-@NV z%PL}&FDgDV&Q8Z9C@&>B3Ye~u%3tV@arS3v++z#9NNbyRC-YM;&5RePKd*~AIt$8d zmFXn7UNAvc6;i5^6P;N4IEpaXMb3S@#L3MAB}rhmNk@SUr_|;lSy4JkCxMPM4v?Q- z@EcN6URR(AQH10nanx!$B34ZKFs)+*bfO__j;YiW9)6SA=%R~P$`!nXfdAqxNkkO6 zbQS5yR8WmGDn+c@NUETqodS+>XyHN<^(HR(3n=R~mOt`bN18s`09J(rI-s0H!N&l? z%I<&@i7TgJ{t^wIKr4$z5;KZ!ttk>Vi~%T4h8$Ch7=V%z00;^_!97e|fFi?j08?Z* zp|JWE1eD*)rWpfdNw>zF5^|p}(*?U>1+F4S(0&$?Bx=&&00TB@tgFE;7OiJsmgduf z*a01`VA%oN20)d+&c=Ay_G}mcOfz6d7(jj*oC4enE2y^AIa>oY*&6&wDb*~+ zGkO9D&)-1K1&Ys!?J^zlmo0WA9qwUxmQ(3L@hJsiyR!ADS^>_7%r7kw~)w9FL>Fj32*MXnT#t*mi6Wo94m^(%!cfVZl=AsjIu9MKYM z5Fb&~{nWJPjRj^CWb#)rTTHXIh8vw;?eY{?0o88e)B7O+HX?mkaZJd+AGK|s4#f$j zqrX<>0Qc8=R8*{7rWAchshw8z!fOI_ZFB;Z_w&+iL{`an!I2^UV1SDS9 z5=Tq4wl{8gZ6$c|vGNpH2m_WQz7;Hsj^6$apUUC&8{1v|4IdMnR6Ckd*Khz31-wW* zFr#+k5S1Hm9P(J$jr0GqZ!#80Eru!fp<0Lln)ps(8@mD5vdr3m7J;LvBxeQU3CR0a z$Z;bW#^%*%4;!sl^BizN6CbjliY-cV7xI^9Hde8DR7&Y)(1v6S=ypWa$S;~9D!5St zRIbrt|9t69o3evUquMyilEFtuH>#b5VCq(`psFY{OR0O^$q~`TqrOVB(w#jr=~OBW zB5YKM#UA*GgEjUBtBR-=xhG*x$cZNVDt|$qiR9A6rY}(nOzHR*n{nkJE?|r4dfQ@Q z+|7lUX2u=iFH|+ZmpVGfiIa(l633`x2Q~>AQt+A+LaqdAQ`8|`NOn+*e__p(0STnl z8s$q}MH7`orWH(@&;e3H30*_Z8pBq57pmFzqRsu&Bn;OmZ-##WkCeB-9*iYZYF{#o zq$f{czM>}6>9rKd-_I$VQZ=nBgqg~?G3hY^x-Uh z*gqeyn#2lP27@0BbBo2nb}vxJ=ue#4H-8^SONPr_Ls&`jRC%$f2+;&uY}a{1LB^7* z?5DO~-iVnCJFkqqUcu)rF>BN!v_1@QB$$j_rHYN!VSY>O1Y zuKYOoyV$8Lsv8lbK*>!B;Vq?jAVPt^wk+>8Q< zLc5JE3;Sc)->=ztPAUa+4RR*m8;8tkc{tK6WD&?osof}U*)lR2VHWbqsZF*V5DWfE zc%4lCw`mT&P)Hg3-tzWM#kh~PT_j5;KtkU_QUc=Eqz--^)2~GQ6$TA!o-+M_0reBDZ?XDsX$Q;VVO;*@&3cv>O3ED|IY2iL4{KSMP{1Y`cfYgm^76ytZBDxixF4{bL zw94ASy%J@tT}U(~bFoCfTom93;nkPKWW-|-j~i?Ms9akukzCwbMl%_Q?I=2rPO+dO|m4-VLXEghpmZIpcsiI4GKx;e@g}u##0!jOSUkw`l4bvqD!BHN%{;w zIW61|zyZiy#fc2dn8-`-e7* zBa=v%tN^kl%vLCGI?s1=Xvj{ql1r-@%ATlH)Xu{Sl7Ju&SdzR^epy-}i7VXr5DD%} z?rN80nh6i7uNQL`)?lu4@s@<_4&!z`ogBjTxtJ0U=N4pDC~|$2w+C^>!c!Q^RlE~l zjbNW}X{4lSMqy(KWo$g9i+~t|nya+2lm*0!btHkpVY1m$Idx((gn}|;h?oYdOmx+w zkfbnhfXoGj%Ay5{+=IJ8_HHcO)xx+!i${dnVd*_Y*XY`?^jO`EpdqUZ)AvK8gL$gc z1llKnvqA}nS^>Y>4x42^yL>j^kP%~u5@9f<~S_&4@WL7 z)+=q{NPE7{$Wbb9FR+B7j;*>h6$0UvWPW;t9QFoo86A!?C%xzm+p#4aSv_Q@|Ix^v z*awsh-0DC2gssy+EFAg<3-?Bf(+@6pL2`i0DdEU7iX)RVc1DMz?HN0z9>~BgEe0HrR{J|Gj$=x|FGVv1VUT)fTrl^$3CW8_5vhJ`>q#NfnT zRw@PtJ z7p|Cmd%9oYwy~`7i6)TECn%KS=TTi@Mpx?!3;Uq1P}h~Z(t#CRg%h6EGZf(-d$sg* zoql4w@)uZzU)4^3&VdP|xi>h)D%m99$E-9&`QKOqFf1INOwHhMNOCt!^D>-2$zB+& z=OO&5ys1eXqGhzWD;%sD9>SmM-jN)SxNG}7myVIIh~xQmeOfFutC&_tS68V_Hkxls zR@RivwIwTRO6J&-F5#9iX;*6-i@FvLmLSN!r@UkDr8@iBBl<}8(*Og_CC{SPA$gnk zU&as@z-Ggt#%wC57+?>PnmGBrPn+dhGnMT~%lu@Iq$qlqZPqZb6xd?{pygSm*eirw zL7;^~oR5g~LE7>?z=24%MF}+#v)GT*JSZXubaJqaJ;0?%w$a&PM)_2^ldPf{%Iwm{j_hf+8`BU@_>9A3(z}3@ z#J|A*=I_ac?Lv7OT@VPAr$^!e?c!Ml0#y}(Sw1E+prMTw$b?{gv_fX!I&WB3>g3AP z*ygqfMYmlCDyV(2qeQksUM=)udYL+nBcLME0H$HgvcuZIHn!ZbQ$S>{jaT{!>!m z+vccV%qa|nK&T(HO$%5KEreIjyGg@_C*Z>&1p*&gN#U0xKqksEY(vr}6==Zp~% z7tBz^g4Ddgj4yZ&cA}BW@kSy~meE&6MHE<^Z$y<%am^eHCSlEP{{f+tEd%Iq=-ac5 z$WSdOOP!J`sNEma0QQ|2up8pj151i+zi|1ALJO8f3)jd9{F07-hk}o|TUi zy$Ub{`uaL!=6?|MGv~hU4H`E}^PB)fW(H&Aj6H#2LzvS!3U_`LQlstru4*8rS0)h?A@K(x-Wi6 z26D84;34Pfh;2eKBgxDRY9u7^SBr1%kM>AndZ)*^#`a-~05obCj#h4CvW6JO3--Ks~Jh=mfmPW@8OyN?^O$ ztpF5DS{C+>aknkCB3_(qFPV~}|aUelUdTgfvmi+1VkjcD6P1}I| z6$NA5iak7vlSJ5(5&sfXeoZYUA$EW}TT@r8Yv)k4CY`Jn+y9w(Jv3>BNVHcS8Jeoz z5-GzjHnDd!R?k&7(H?ymc5#Wl#leMQFQDrsA2&0;tt+U{Gj!d&?7L|(`qER0L)seSUhBfWO@{9Pn}xL5*-%-6WB>0 zNs==170gwv582 zxqz~}uwb*!st_iBg^Ox37WAb3Mv0bV0!z7ADU`D^I5|C+hq)T(uFDk8^1tIB2umvjFNSYKy5obk+;|9ZM zR<+_e9#}{Zn1~j>uu6$gq>hTt)cvFUu~{_PxT|p=LGcDM7LbP42E$D|8xnS-o~;PK zfeH|(#wtzX_ZEAW5jRNoqA^l`2ecVq!7@k|vL?p|9>?(Sf#UTAJ!P+px>fdpb^+Kk z&n1Re6jkazsVbnyRCr!7}*4Fp{s1MjZW zhJWg{5sKT%aCxy{!$ixV9B*vY;X*1bc;Xhq-PdV|W4DkBB%xbXA|0z+#rL76nDf4C zb*lgmq&Pm*iET{-8BSTtSuJ_60WG;)Do_rm(lSsvv7$Rxf=kbAVa0ZugL!R$tTrV& z1TMmn$p{q_44f!8)C&f zqm;59u0y&XRQEcOmbsSBo}Ci%R8iJjjlx*V%)#+M=4LR2k^*F`F215ER|HY4woc|E znTegiPd$!~>UJatKWkT~Y}fGPv4H^e1z$&%(Yl)xt+<2(rR@u)xsLuxaWo;Ce+$3L z1Er$JE{SC5q+AOjSe-@FrN_1)I=PdA|G)Iuto~%zob|rfrzDXp`aFd>DQ3{%5-2IA zqsLN~rHbAmirb!)O1VS%GkRu1KHwYcldA2M+$!pqTahchZQsE*Jt`HyV{hYk)S7-k zd;ch(Aghc@5#Ov^ZO{Z4cBrOrwp7n~1dR7J7IJZ%*5IzQ(7~J%2~fnKNBh|M#jj)#9l?&=bm~!V19%Y#HIOV_kyWw97igO*d7Erl(0>ed zT6C#}V3_2mCD#gN%0eVnT@`n0odYj-bZORjYGE78y}~Tny=OBh+giur zSJ{x(cvx^YBD9?&p2>G^rxyB-!F)$e9bd;QsV85Xa$@LL7!Pg7HAAs|;_Jho$& z$&U@=v1JHM=-lutNaDs_D9)(lj+I(em38Ocv&Vk4o_6miDqD^Y7HQrtonL26ObV znm?BK7Mw7#;|e#WgoZ2&2k0o4ivFkQKl3-aGwCKuEe-o z{rE6j)=}$`Je`+V?bstZV=+|KBRQw=_(rqfBhL32@^9}=QU&z<(Cgp!6#Seb!qW^> zarw-EMaypfmuA}!y#t(Q%{3o-d-i_TGIpuhz=~ZBXYJr4ZvsDW^N}|UU)sYz!t++n z&erS3Mv>#bjjOWx<;ULD)8*_OyDBp>Y{|*UL~C6I_QWo0Hml#hwhS4frfd)1nppL< zW@T&h{DBAtnB5!w7W3dI-ieKgUp1lM>4vnq?<4POv;I?WbM;Lhe?Q|@z2z4f_DKI?&G+A23#)~#`By0x0sb_e}Ma` zZ(d6K`^H1)XQpNRUZnbEouZGH|0ec8KO*B#Zb+V(H~giY=lnMFOvWcsuK6(IPjY@) z9_RTdJNTsE>ic^-D@;1@PhkM31wM%l%2x+|hh2UIx@6D-1g7}Ktbg4$@$z4KcRg5^j0G>QS@W8WM$Ylu4mkmGk>{rBXC&bN;23S-Z@fQs=MTAmklY?{AVUQoGS2 zeRYiooBj=cFU`@&2LHZo{>6-t^#1>jtk zIjV=>EBh&$3!!uKG2m(Lrl_)b>w5V4{)rDaTxVvo-fJkN;7L1oA-PB-&G9h&VBr~ z&O>HIlV3>FfAhqLL>N75j%)HaC$MB$li$N>h&^&*=(#N87tCADeosd7akGCu-=5vq z--=Hj>06p7$(T_@Q zGh4OLyEW#R7JmYlU$*#TxxCooAIW9c{{AmixVL{0m;879L*q+7bJ2JFJ-A={9e;_l zrhM8y{%MZcX@I|wvcC-Q59Bg=p#6wTKXcDOf48`(pZU}G{ImJw!0-EKIA#P2HvgtS z!V8tnRt3MMc|P}qs4rI0f-Gw#UoCUqp8jCx6|-zle`E7G-9{|uV6mj}8w%ANAbX$Lu`7zl5*<2YsLLie)bwLkB+mjc15`vZot@a_ouh5KZ#Jo<7IU9RzqC-a(SCWL4zaaTCZX( zz|dzgi95hOD#}%28Wz&{;OjK1D|&a&Vg8_gi>-U_$YLtqyJMldJ|Xnx?}zyt1LUoT z`;Rb9uO03WCh2;#aye|uyX8JJ{LLJSckc9uaXGdVFj`|i?DUT&-@uHS{?FXcedGPa zzm6Yo`U#_4W#0XXKcpJN2IxpE4HTnIpO%}ENBHB31!1gG{)IN{9l~0ygvhuStxPnl z<}|jadlON1)e-*gRQ=8o{wNx3KhpoLW6JA}^iOo)BMvy4y|lz!dNhwqOn#QXyLvNy zmcNGmKl&Jdn7RR)N)5?*n@g?Ujzh9i&hCo;@0w^x4r7(kx}|9PxGq-z>X@i_l( zO8;`4e>0bPv;AR;tQD|TH7EckCyAR!X0ts$G9S+Nf9(9;{NQ+h8|G{A@&1-voqN3UAM1KbR_xcn4vz(^yg#p>B3e(_q zQE6F_|HwoqgX-6q-=7RrtT9KO;tw-B@F%|CJH8Au>rS!tOgj~fHsK??mxAtlsr$aM z$UwV`19GEycYS1f%>e@v%QVNI(sRk3)p!_kG~8*f&~K-k=jQk`iNRYr*B@#+PxB{i zB>awot`6lE(oTKU-dU`V%??&Oo#7ZTvv#iEO!AQzPV;Z4zw=M`zw3P8ym7jJEt7r0 z85Z)&XRxZ@H)oycpFl#Z&(HMx@>}y+%-!jx^DO_oxXps;cecL^+4E05*Z;n`_iX<- z-Wqp~KWY*v9@>UlBD$WA$2vq}S7I{1q$ldT>1>FH-&!f%nM7>Pcpz2pq|{im;9Kbd z=Kga*tdE`JXM0$Mb}qUWtrML$>(24NM<2GH3r@D<-jtF2Yp#Dz+>8B*`}^~`{=b~( z%TJ%@_jjC2F1yIz$Q*fz4~IiQNR?@U8l!1|2_~9T2!XlJKVRN_o}a6HbI1jLo}B-p z+g4CSOsu}SpSkb?fNOdA{tNuc@dx9QcP+X>VywRVe0i6P{JKi5r`{PfwA*}7T{Yvo zSbcjxbM<@?)bg|Q+52rVsZ4?j)f0sTCY?R*VyI^FMmPR5d1F6w)g}ID0O+wx;78}1 zw=VJLZ*|`OnGq$ISSaU|=-Mwkc*yFQBFnJ-{gvri(XI>N3I6sda);x=Ayr< z$X8J&vT-Jy<)oq}6=B$sRy`Mes-i{}?L^#wRhmas$BcEPofz>Ws(f^RnC}|G*ww* z&6(y|Gs<6yBaa7K$_{sGvFmd^?@<`4%dP^Hl6{pA1Wa$7XMsr_RR^ZAEb-`SzIO}l z@|d-xw$Mj?>)X}0WX5gZSc3ncZ>6cluJ7Z{ZCvf#f7G{{&)vcRTn3W9^_8b>b64Mz zrMGQ|FgcupO@4;AUX(;PCC~l==P)2gdo(nWH;EpF{QPA+s^Lc2ie2#W-V5V z#wuZd5M4B9l~p!iGL^C+h+g_w2FwkKl;o3m=6lr1Rs4@KcPDW!81IP&jsYiPkdD0CK`c_u)9O#qDh z(WT6Pd?+9M5y%FRscrSI7S&n}nVX-B&Jn|q{K~x%>5jq}&L4WL4i4lSdx1-UdNF46 z^idn^MJet^_g(;=b~5&eKPf`A)b(Or{#@IM!xYwx2|$q>M-@lq=hx}n*26-nKrgRD zhK%>FD_o?*kh*W?Zv8Duzg9bK%$GWhDsRIb-cWx*L)|LVKuyQn%IUJ`Dhy zCu4_T0A!}=ACE*~w~$?anLU^r8A0m4u?MoAGaTuPXYwLGc8n3@+l;W(9Vn1+0E%ii zaN$Q-h~4>-9|8*>wm-n+nglvn89-q%38X-+aqpz_w`X(k7Z8OOO0lQ)a`#Yxk0*3% z0k@Rc)+44c*j<#8&%-iBJ{;|~PoU?zKV zZ8Bz=Q<5Ru!646Bx0|jeq(rjbQBYvOy8>xn2DEs}<4KFIpJyrm23HMi)Kxj%VH07@ zi_XaI(r6QFSQMQRUnlld865%}TmCBH7&=j!tuyB=N5|Er; zT}+7}mBngVIyMG6VKsJRvi}Qp>^Gc+Wm(qr z%g~dtHkUZm(dzJ-6~)%X0S*~6a*RKwIl~l#Z*jxP{~_T~!;Cp<3~YVITs6jT#{C_m zWSzFdjdu4EHexBN1!MN)b`=mzu#K9?|2bhdouipBRSwnN&`y#dsqI#$E|bKCRk2{F z=H6wG6>tVj>oZ<)BQxWk=^@lPUV5v&2{Awc$K^oeQd@#8CTp&%Ua$z3T zR>*-ebNRn0wF0N!*ee2w&WnR}aIFx{drj33_`xPcw38$yRIUnX=Fo5XLl0zEZeUj9 zF^|P#j7^-p4*mmcGI08sfUR&FKC;)1_eV;D{q%T0 z9A*2Nwf%$`%AHP*4BU_)s;jSfh1$LrHuVQ@xUU#NzNxRn>E(?v5;G0bTW>kYSf*v^$kYg{yi079aUmJr(z1`yNcWWf5WVozCsx#y+59cth0sACTFL9B&_y$ z>}l$9lm8^gn%g_8p{`+G1RA!7J2iR|V!v@^aMm38wJTFu7@#b2)F?ar=bQWe4;A9U zzt0A9qoz2h0DYBcI~}mFJyED1`Y+1~&XsD3PMxVMsIwx;7qU}`-o$c%2PbY;DI0wP zwJh}K|G^ObTTQPkvP~v`aea%Kv!&CLiJFN_`SB!wAAiM%E0GY*g020&!*Papzm>`; z5LEG&|Ht0F`8O;; zZ$22o1dZwX0O9*<7tHLlm0v6g*!|hocV|vs5l;}vNh!i<0K}EftVyYSocLJ*W9)9p7L+z=vO>Ql~Nh(AropW5Ha8KmF!nxE7$DP{h>mEUWt zOl%)!u$G=>soTl|P%64FzuvtW6CX1P8-%{*3DSq-TW;k%TN|F(7F6P|09{+hhCny! zNvpD%LB#XiWz5T4`_22uupQ7BVvj3=FEi~I07M_iU29x?<%dqP|GpVFjQ7f3OFtSuCdQ>D64SsL|5 zuVNmUs(RnE+6IkrYr0qd4AT+$8$~UE3nD0AGtRgY(qvUCAv}&Bs$SE4Zn@DWL7A4b zci79!i~P}X=D~>Lbj|_ezj!)A-}$%#I9vHmxccKVDuELgvNOueF1VJSuZ`)sr3Y1R zyK(zQS&bW$qtoToGt8X~zIBxv1Jkk00a+vx48tUTkdHl%r$iVFMe`(K7g)r|V{KpZ z8{v9~|$%P?vbwC1cniLivfM#l@Z=Rgql& zx~;G>3(u3m1G=h>eA;&Ypwj3m&bQmb(R;Ls z{~=*?44edVIx~8Ezpa!Rl}h0*>>RjREJ3o4} zavOBLkhPt%73V4yk4n|Wr7VG1#B|8{aYEv343M}O7GWk2kL5z9yz375-jv#y9h)gW z6ShrC5j-L^VHsyT$y72bHJ7B4xI1W5kLA(`AOV`HpWQSE{gi_4PUZr%pJ0C$5m5sD zg3@PI)-FCM;LmYxD7$d!QRev_{o#lA3R|@6*qI8fB=ENy1`a8TJ1u;R%m8roh#^!s zquQkn^&{@6Y=na=F!8FHIn^JW|8jF?$y7wHGt7NlO35JqyBaN3D)f-akC753F&J}( zT*a5Q5>YsrvkpgXZSk|k+=G+;Mkof5$cs6E7_=Ua>N6#ryOdHDKw~87 z`{tpY{hu7sD%#hzrMvps{~?EwnT#xBXXIimRn;lFf3Nifgh`y;(Am- za-He1tH03!%ew%3Ru_ENg*|L-w<=8r!<5MDX+R?F@s)wWe`#PDEADGxbSF&4 zX6EmTA7w0ag9psAUHw80@6&AlwyWQB&+hv>dXWJ~DV&`#@DovDhU{8jTf4PxB`^YFh^l1xgWC;tyoyR}wC5Z8vy)?L+V zsC$rTg^M*?Z_qLvb{`GBvYOlzX>zBs95ho-saZb{eF&X zzBnM;clZ!X0&A@CG2N^Dt(d}h;6U}aclTR&$)FKWEU7ybdxE+H%i{zJJdI;2t&0W4 z#KR^9%)E=&`&5BwVoygIl(}qrwz);qr=EKf;uC{*<;Rl!QC}q<4gAov`?$$dY8OGf zpBaqV`Kh(b$K&(bPy-O5ftG- z>CaQjTiU{9V_^rP#bdXA(#${5o^ww=wxt7m0-e_UjAG zT|C)fcqUu5hG9S3M9=Lj@Ug4)S@h}T2)r!Sd>~z)?O{ZojW2?u@udti(iB&FTl0gb zAJp^xY}adkarH|w3_!Q5u9SXAMiM%S*2%GktRZZrs)8<7LN5cP;)3DWToawa6jh(kk+#-|xxxEaFFFXI-FHku1=l)N)+`ZUuZzNO*gA=sLo;8?W><^>n zQH$Xqo+OJtp2YS&g$%4)>_6??VeY)b{~V3@iYxs`$*h0YRsJEUmCJ8mh4z$B#{2?z z`bFmEUtq&oWM2G*{~m>FuCqO)aF97{sow)%GHdC~7E??fJQ^@ffGF;x7cTWX-Se>l zed2Cx)?e>uIrm`1^}b1S%z*j*4gQ#{Jt4r29x+?r=G|e& zH~3>YEI?@^0NO1HsNynS)H}$Nn7#Ln{;X;ZG*rIPpF8kk5}nCGHa?GmZSn;Eza7y( z|A7DRzjNk?zhr#pn?3&S4zv9$sXu7K6prM5DHmG)0f>ML>MsP{lauv}lap2QkQMM6 zi^4cC*I|3q=2NqEI2=X)8)Ymj_Lqr?{^7G0my9m9#zobfW-a`#RA_p=Z9-ZyEyPD} zQEcwK2?xW6O`n^wC!Am2{$^l?bvou29LN`$U*6(x%jMl${Ei`7BCENz_7*%-L+e$` zcsPP-p-x@!^GnT^%lw6ndQyO;^#CjXd71x;!xXJr?(5Ww50>N0e7+fahkZKtSNORv zFF*7v+zaJT3n@xrLE(}qHsDVSXN0`ic)NdR-{)?&6F=t`JMqwK(ly}{`{M0@@N)C{ z?fwY&>37YDUlS5it$xL?0qpA2_wVq3@O_QLm4Ix|I)crsxYak=@l@7#&QnP<*YtK9 zO4(CcQalI(lp*QNseCj)dy_XMRbOZlnTlZP=_WavAFgE8Z?sN5q&DagHs)U_e^JJ9 zmu`-{lgQ`KNJoFC|J?8wEVI#|=xA2wghFo+AufRF_$(nr-riH(_#m9}(RcYx={}Fh zLPp|?xTp5UEV|b}R*m+!&;Ov(xJUj0vgZ%JAAInF+3|k=iXk?LAO+S$n&yv%XuC!U zRh{VAo_yvivynY$8ma#aQ~P6 zNMSU8WNv!We}x#9r3;?&ovq_o8!}O+6>CE#>U0uoLxwUXiy+l#5?0d(f7=sm8JR_s zGIQYbe!rSfn|Gh~7j}i(od1l!A1KjS|*fc`+hHsFJ5yR`a`{^ts-S^ccPpUh`N zp7VENU5|XupQShvsFw}UFzcW52Y$CJ^vIfnP`29S+-V!3WK%BxpN!?S=l#RdEU@YI zNUqHUfAX7%tJ!^ZP2SK^zy51 z{}hV`Xb?vHR^{Ec7a$imn=N0!rS=}P?+gB*aW`iRmdSNtuRznpG2fb@glz>fZD8}t z02WvCcU9xih%cMgM&#d+!xV zbszoNZ|i?^R&Yb+mr1D%C=TTpngI63J!bk}{I-_(=eS&`=)TIw`jsJ_{1<;hw$iq_ z`!D{WKDL9P=s2*E;pMM1Z}YbM;6hXP60cXMaHp5L#sd?RLj4gtV^l`|rFpFsSLgMr zm;81*aS!#3xu-I6o4j0_d`6A|nAONvx}<4{CwqbM*ZM;TSEkl}+fg%X9TU=H?Gof~ zHhZk~2Mn%^vGV2)q!zRD%bS%}$_v)|OPzt|dXTxw0xDmFbZ*g8nmN1#%|3ticNt#k zQ8G!a&Xrnz%=ou2e2}1yI#5)6XCC=0^!ag0EeyD?Kw?&#@vrzpyXO5zuMp^Svzhw} z@luP-Z(i|t>?H&ZA8GLtrxNBDm0Q>OI-{x2e#i&ddbWgd8WRezKa=7MIwY!vvzczdO_?}< zAx>qmQF)X}?c5=7lcgMGUWNi?Jb?{BYe^7}vYgl?!{QmBFaQ+wWY8O^x?)cWp$C#K zXatI#LSD|V6P^PTYKJXb?=18EPmK@;x~iJClDoSfJ-79!((KyVPqPG<7i z+2&HntrblH{)59{R7#E>zBnWzZRipMMP`U)W0Lq=_FB4mJdG@2m7LWe(ZT|(Jl^>N zaRjbCE3|5r1<+75GGYH=HnSWL>|F#T5A+ z9--)b_D4Nvh*@^?E7>>979Z1Tl7`Cp9L0q?Q5ScjF3!zl7YoMO&QoWkny81fBb=|R zNBFCIRmHe2n+KDbXWFSwlW7xsOPL&+*WQ7Nt;?@RyDLqFf+e}xmF~6Ztf?{Y5){G zDd%eBK{Suli}YuVb8(tAZ=X22bDBN4V@TjT&djT znctu~NT;V^^oTUsGGwjobYkz8I)C8%io#y+OXb(M=EA6l-YHA-^z;zFbf_VRizHS~P|ZSTnRMg+4U71Te^&GtcPJ=aMBGXUuz( zvq5h@psmASTutX4>KkL*y6JcRo^A>kZaF8>(5B!aKbQJ=cb!O5B z{-!%Bolmll*$S0AZ4;Qm$}b=r8rp)jlA$DnKrI(N-Q~y(YT45}KJYKto&26w2@tEZ z=nHCD_M)<7C7px&ws%K`IUPKsC2oiUPJfB~0!GO0buRdqf5Ap^of=f73R|c4b)~>W z|Mn;LsEps@m^yRLzx~mrnh}#cJbAwnST5S&#GW+XLh3G^7tCf!GEY`Y)oo^>IzPl6 zB=ZwzNmgD|k}9iKuw0y7Sm~5WAD@(wI$6$MWRq30odi&9|7s?elwy_1RkAC0rd;)E zbiX~>32ZfGVXkIH&I-kHSU}P;@K#rOP);s9mP47mN^@OYj;s#E#*mTu6f&b^(4na;b9B8A+!W1RVH0tq0YU#z!a7eqD#sp1A_6ne7_J%#g;sX7Av zX({WqtqDrS>-6rFX*ms7C1XvX9}U>dm7c`>o@vAKDy`wjXQ> z>a^ZOs#6WAJY6j}t)KXt0R@vgk-xBjvKg6j45e|2S8#Dkv>Pa=6fW`&PsQ6z)=BE5 zZcRP?Egb_O+26>$%dT$~QL)h5qidtu9BRc7@To#=Htf~I!Uh_7KWdnU8Mxl8{lwp; zLs~>lwjZZap*mYV;4v&cS5(ZV{0>{qUZ46Cw{7KZGF%3%Qrxr_ggLJ48es^F#h7zo zrZrwNO$qQ|=P73%`xLWgym`p2{gurVQr5M3;=NO#tZVO(j*&1lg!9Tiv3?DcmB~<= zLqT7W?Ih@v?bVWroQ2)qdKgB>%*@aHe1`=^v<2oZ|s@GIX7WM!AD)L(7MPNt2T%$Y4e_gnIHaSgd}m|caOIp}l0 z!&97H&Mf%cAGk4!QUC&<1&z&($5to6B}pAlioFH6a4F`GpZkRgm6x*?SOq`A-vFyM zXvXzae{!oonbBYP{YsUO@qHi@Jl{h4+?Ye+xLw(t3e2~5wKYMd!?1#U7%9u$T6s)x z5yZKoO_fuMxW(%C;4vkqi7_a6jLdMQ_(>mg7ly)5(itoJTM#M##9`=@i?}Y zO`|1Gpsv)ZqNtBnqeGE8LwekX=s8}nG567Yz1k72P=P&ww6E;0S#p%3)>f)g^zErj zw+-;EVB#?XiNaMjD9Q~sxgcmTJ#@(nGFn2^5ok3sWLfZRHqf(8)n)h5uC#ql(OCL4i}HNBi* zqf*j;jYi^9*A#rJCTzuD9;^Bzy0XL`ye`ZHbb*gFIW|K9?2ZmJYGN8%_1DIX#Dxjj zx4B$!kc#$9(3NHb+nV@j%ZOW8rsv5LTi!&&s6MmbG>pn~V$7ZgLu@=ZC^$`KV>j5^ zNt;95V9HRowBl5l&CSS>&XqAdmt0qKmDH4f(LCk`{Rn{<>obHn=XZFt=lGH&*AnCb zP&go`KEjlXYHd(D=qTNO#i~?QFn~NRt9?cbxwQ5f*N>}epAnx-?ej%l4_36x-z%S- zmKj_Ldx5q$2agSwGs(2nRK*2k(oC4p*cMhtU@cbofmXW zo7;7Sq$I-VjM`@g@JY2#cA2Ap)IKwSztuj!a)r5@N~QUF)eCmWlKp#kwp_Cr=LciA zO{=G{pBf-}3mpd+#xG<)h9tSb;fKJgi)qIF!W11;i$ z!Qd!^r+ff;>Ju0R;-a1IVZM0h@TXw4?dFuAY zWU|v#=By4*`KxtcYp!{vB-`^>UqVW$c}YUcSKq;mUHeYuv0Hag{}f67s$Aj#g|tET zQSV?S;Zm}&t>Z^Y*1)b|$A~Y>TfU5KaxA(v(IPgv{@>Kz%SQ(3EQ0OT`AD7unqo{!#9bb1(FwBAY|x9^ zDK>H_%`_IdewN~V?2#DYv9MRC-HcPv%k#EkL$p`P$A7G@$oeodvLrjR4%J|`J|-EP zBt>2qp0iUnbB4KfK(=4$Qk&2cxjQLCIzCwzOEvCN^xKM!8d~L>f{qdtDwRwE zU&ar9TSXjkHRML-L-H>&s&Iumq^4sOs@&kLD$gpR z%Kg{24+zo>m2=V~b?A!7TiPcO02Z-r4n;Uui!^Lx_?;yW3S+@3@Xe8eaQ{oU5F^(-#6GKGi?56O4%)*7vVhm z)x|5hRU#f_h<%F=)5FaVU?~=v&)S1lGpW?02lWjd5XjkK+JLU2={shc%>@I3K9t|r z7W~9H&x~vjF6bXO(2_K8t!+RYI<6S}l#aYx3_3QoD&r2K#ZvKv97f{}Hk~$;Rns%( zuBKv#4KhD9>B^%fJ6?-jyX=$@C#X3zhtINHCkr zdqaX|F8b*ge9`MrlQ}Gn7NY-Q^V3L>4bA~k;3>5)}J=qGsDc;#b64^ zyz+xpg;HSOG`nvc9MjwOX)QWaw^CkyYUALrwDXzSazrq~T`-LaQ!Asg$_l^(&3oGqM@bRD}&2T#a~gH<>w6>=FPQ+N=&tHp*d6hhJ^F1Iec{R)1IO{>JgzkIE|ie-X9%|%3w3dn&OyXpFzTb zZfAY5zDGKfazvD%deLafe>g^DjTsY!{gpZrhC`N3Qij1tgVQjx@$(a7g3Z5^g^7<9 zp=jsGgbX&6qRxtN1i-VxbO%8p^kTeeby9q-YM|}09S6Q1L@6$SZ)HQ=e=Noie2~Tl z%1idUvBA(m|6-OC5mYjA^j_`r8;ebkZv~H!x9eEneI0q1bwquhtRumzJ6I)VQfPW@ z@->UN)h5A-qySs7N$>-D$|Rg@m6W=h;~GCFI%s)0hfAAT((pG4|}((o$B#HOTT21 z_e~ZVc}9zzH5ZHzHj3rrbcCLd2>$4-E6mFAL3`Vm>xAg5c3bDa#|OiltSM|73}O|d zO@lENUz0?(m&i#<5nJ_Tn+Bn|anqo6OJP8&7+FM_gsQj#bl5i)^kCr&;R<_Z1;AYG zC!VP1vdw}iO{zdK^>JW2%4ZF5pUr}4?vg9b(#?Vq&Lifj%>o&`8z%(cp^HDBz*Ej# zF(H`ttsH`aL=jyS64xNt=LRbc(ny^MgG9Z$nD=23&47u)@tZ=&5X%+i#wAN0zw|Ul z_u`FgdMLt-C=DjGcm;VGS56RM4zm2U zOtWVF7QxUxUZ<60U?2<5qSM@woMbm8^ATqQzCd1$^d8%~o{Zg zFc6TeoTr74KL+Dpe$%qo^7rubIz1tb92?!Q0uH&v2`$e4CG`YP2&_e*v7VJ z^B>u?3UQuy`7+z16;vT!FRRQCw+Rj}kyDfpT8h%JbJLFCqnx6EXEsjo?+8k1zNUNE z+k)6SVEZR-K(O1bgA>yDk&)?D;sL}jv>qK5@?E)_?I#DrOG|XJN=LMsORSG(3*u;k ztQtFLT7`1;U<)voP!L#3&bmr3sFjF6(M5wsO0gaw);$6Gufw)5Zt6lH9WS-?qUX6$ zsTSONwqxul+*=5>uCz#;UtCtT+a$afCI?xsy^&!S^+z%I-O`@QK{K^(8 zmB4gxT0LhEg3TYC#qwg-v!vG=yV`q9fxPyN=m3 z%eD=6E3rqW#si|9_sikCxmEz;q1TM7#@iJ=43jmRrJgKAOe>}z^2tB+^ zDdV_lQ7+a1{_v~QEn<$_CeSXLDRc%Di)&Eb7TdD(dpVUVYzivCS`6k800%ZHj}{`oW|_ST{bEOho~M`(GGS-4AZhQFGj;aoXj*I?L|Siwlh$VWuX zT3#cwJzPe52fI7!sJ)(SWU*KUY7z4G;{%b<#hTN14T__4(F$81?39>}(2bDMVvl1h zs@Vu=G1N#ZuvSm*8tmZnp!pcMTW~0finDiPJ_sM#E!d0M8M`}T?ILsh?!ja3**BUU zrv-&!pWLttO!@>mSxZ*K3F*}i3cMtULT2GW=)CBg1=HZ%&kOn|;Ed0O;JYn^A_) zTr_JU^JKVD7=hX2$3fG0drZq=bTlphwIpyr!35JOnV1~YlD1lm>H#zc=lg-?u49AY zX6=uIDYp8kF3)Kr;w1+y4-NLTCzSv=1kNTq-Q%Q^ z!ww66KY*I~25DEv`2kg&)sT|=1xrl-rX3zk&1z=Ub#v9>LBGn=>*l`0gZ)E0H4~YJ zwW%4=br-A@2*Rj$O~V1V6Ogsf3}$}5`T2}sZciGN4oE5hXw7=FNoVjw?`(XwA216$ z5zN<{`#OWZ&O7EAe&{Jz5X0a$d?x+{i_B9qgLCD~z5h>w7j)g?h~PYm zA3h>Dgv+QS?PcMS!SOsb9EGZSk=gvH;4yU6*`uKbi^%04?2D>!#nHh;p58y2jlZbe zdsc9qoiWSb*cpScJIvVS#{|D)9OnR_ zZ+=Gbz3hrxZ3An}&(E(zN+(HP3*8Eel8#_?X$++YruOXmi=)LFNsILha( zxtK?uH{rR#+f8p-#1ew=W4z)DuN2M;`b@Ah3-c;PS$D(&y>jiA`t%~U6d3^#IJ)-K zl5#N6oO@nyuzSy~<@cz`ZCyb|)ey3sKPChO=&W4x(@?oZX21o(<&Eq*djuQ|4xNAS zg5Wac=_i$pokC?6jnq##f!EEf3o)i8PnVgyFATQn^-Iw!I)Ohd^eB4zR#Sgb@Pu=& zdGR7`8S~ji!O_k}G>@^Sm)VjqLoHW!df3Dei zf!%VQ3xa8m^G9>{#lgX3q$pexZ0tO3=3E^N-tlQ`>&T*=ga9{?dIA@z?j{~$^rJ6X zg1%Z}{&saR{Y$nX^S%EH{?Pjj>!X{Nt71elfzJFN%UfO(%t$k=qe#g1Wt-8Ji-H@S zzKgCy?6-QL9%2b`Lj=a|GW%a1Y|r^V*IrKl>(^)xbIQG+f7JZ(=fQ4%{E->9nEm%F zv+rWmRqM@pR|KQY^2I?b_Xo`85TtdB(d+)o9B@VD=e_ymr7M`=_2%1G2KQI0>3dah zdb`@_VP)x_^1)D^Ao!WMbLCSO1Q~bS^>ZJxhO{@h#)hq=+>1m@-7oC3;GShR07w6g@1=eAW_V|evR}k zU(PefFAH{et}j2l48-GHZ-y-oraO0)&s!c`;0$F4xtwDFG$!1xRRycQ!P;x$jq+gA zt!@i88)?~LXr`1Usp#)iAEOZQMZ)a1<#eq4Hdoyi^pm}A#clW{Ei&obgOeIRT>y); zDZC3z(#7Wd+cB>$H_LD5h4tps+k@%u`yZP9e;xct-~Hy-!I1B+)dzi|^<3;4)2vlF zse59YaJ*CIN`@&#nWhIo0r3!U{BJlB3(0h-!f959X;$496wCp40G*4>iFX8RHjde( z!$1ere-M|KZxQ8~Zjl&zvxGY`-?}&GGsq&i$-IQlGr?q&JG&#YYby-JWoFkEsKDo& z6IKL&B?ffAJA-ivv%;ZsFi1@NqVkn@28$gu=^8=0%FS@@ns2VUGuX%+eRptfSB>sH z!3UFWhxEh)bhRQg>CXS@AS{P-%Ds@R`DWFoE((G6f(y#ll&D13!+Gz@U7(;Aya>028g%jQl@*v*!cBz4Ya@2ZJ^<;=w>B>`4z= zd5NNqiB_7_tJre&Y0PPJhYLz2%E+?6HauDa!ar>f%*zi3yT$HwH?WVNf5?*V0S{Z! zJ?G)T6X`ztciR8uZ~Y#c+eN7#cqDi^p}m%oG0Pr>YA!dgJ{lZsiK!)MFPOd81W$K; zHTJP!UGkL$05jQ{f&TkM|KyTiV76b&yuVbQxi)BW zoh!)>$xx?oc46M=M2pE}Zcpatu2=KyL}=V3lw7qkqEnYQXHC`gl6 zl<~pt_^iSN@-LgMUd4j2$n5iKpoA7rz8Y*&C-{{MTmCuI7W;dq;cvmEy!c;#3ohoe>H6R$=X>Smx4~Wzs%$Bz}^1K zy#G$nXWZH=fl)kKmRtow(rL@lgV#_3A%6N=N-QD%Qi+-HE?i6Z56v&$4Sv`Ari5!* zhuj4!@64Z8p7UPNU&Q(Hf55e@qY;Snyd}2g^6G!!6EP5^gV7B{dJQ%prF%x&XNP0s z^6K;VnNR*1yyje6{_6(-1Bj~Uzk{6|p1=2D@V3)@pZ!E9XY&bxFtEaWvfszS&`bZG zeP{D)i8!1hVjG-2#d=dTgU&(~B~BF0_5tS&TrH-cHh?v1`TvOf4)Caowf{Y5H_6PI zluZap2!U)ufP^BUNiPTKO%xRs5Uf`L6%Z9`LJ>lfAZ3Dr1VlxOBof)6hyhViKq8z5n>^&b*(W z|8#d7JyC9AiVEBfHy5o|VS(us^UkDS`0t*Z{M)^PjVsd6&|M4_Cz$nj9lY2+AF zrI)j0JQ{Mycc;q!oMnVf?a|JaDEkYRfSf1w`;hLHsP6oV1$KL@=ryt~10 zZeSCS^JEq=X2lr@ZstRrY6fm4x+iTfqgadhtg!=%m0#gVFk^Si zy0Pqxp2YgdYJ`%_3Mn4rYZuu0ALwAo_{r^8>Pgi3xFzsSWBz1K2Ai~ zus}znWy^RLcZuGn%Ln73JOmv5wRm=ozHOG{#u!qQ5r3nwCL{jF-~{#%?pOI(ZT2*h zqieA4#vhcGDEkcpnc`0R7!O|(P8(9S*o@%!65oG|ObBZ`x86r49oj+*4nlELl!sZclFt1e4d+*j;fR}d%E+}DVDY!DoZT-AWJ!Q;ct z{4(qf>=!!&Pt+3+=EJ>NtQOb=Mj5YPTfa=fOVFx7jEI>T{GBd0tcQ|dDv1{klPf1}G}RxR@m$~4wZz}-Y;y@q#>K~;JK-$hpaE;+NZZXE>! zg_Ek5xe;Yxltg38b_QjkR&sTL+U2)dEI}5b435a=OqPfN+Zb@1{vtD^Gctd5WUas; zJzQVNrNCW~dZr3!GU zY2MS3NxctQ3SVVx}Z)Y$dYH?;EDCYQ2yVo z3gL9lc9KIHvLQGe8yd0`?#rnU%3>FUtpSq}T5d;tH3U)?tl#x8=EY-xCV;T>y}yLZ zkD9O@h=sf?o81lsnKfmtiD%rUDQcc5mo#OMg7cKpj9rgayuTSvR)KuB8LLHnGLY=y z-t{Ko^-!j^SNjRKlzW=7M_S}<0^!{r7fT-4N9W!^Vk>gAWP{`oD&* zkDSntvo3Il zRd_i|N~)}r#5y5`%5|Y?tU=8ENjJjv@L?eF->$BBoKoV z4K94Q_h}XG5t2@LM6n^rqPv0E4Q`SlB87oVyEUpoc>313r1IpKtyz5p;f`s;`V*ge zSR2+XTCrp`GlM=@(uTD+isZpIthRUFCSbffCzcVu052t9N~8AC*l|JZ8WO{Yp&iXv8Z}Os;1a+dUDk8KWWRF z#0FZTMsTm9g~WEOp7D+B*p8hHDWs9RK_AzGA`>A}~ zX3Y^>`W2fs2`wI_i@Uq9%bemgVV}zOU07`#k-=Tq&w%%Xu3#&Sk_BDaA|w`fWpB`{ zZfp{0+r!;}_)U_Y?remyPu|-dXQ@IKbY~p`?!FFmXHSz)vIl#xm+4u*CtCwi)ki(q z03+r+{ADY@X9FO*z{{e!W`e(WZ+5F;eMORD7;Axr?eD`T(x>hEvYI%lgZi?z#&Q2s zeOWj;5L?)fbvB;$@9)RvnC5Il?m85a?4LS-g_#YiM)8ITIFNbTpLYYls~U{hzy4~V z&!~0hKsE-RfbwPR16G3nx@*}e(>N~Q8pJk4Qjd0djf5O~(RrD7J*!JN(<%a9QmN_LS+!I|ra*>M72&ez{#`E&$>)D-+5VjSJK~kV5#|*GDi>IKikUIEG z;+rOM$qvYKrWJ`C4}qX7sIWUruVJt_td-AJa^ z2?Iw+jRDB{#ChZBGWGoI>B#aeAqncWNXr`|h+D1!8TAGif`6J1%PuW*u7{ zQ_;+nG&`IkIDyHPr0kXO8HKG1N8~2j<5)r>IKyq1_j`(}ls}jy$53z+l3fG$E%Tnlz!u>jxvB>tOWN%aHfuMh;pjXWIEH&q z$*n`6OuS+S3ce&y4FQ64O0uCW1&_Kz*>#!DQXHq4u~?fwo}lN3vc?IQo*;Q*DC;Vm z6{MQTBdzRx6X4@6IqoLbI63$oBo9?4HcFl;Wr=e4O{|%<5t|K4aM;?)rLN2v#-6O_ zOfVd}Dp9o4U6q7*%W3nN+&7HX!O6NXj9mtXtB<95w4ST8{>Nm;;jCpc!9lAVOoz0Z zk=AeX!q*mJXb)#e>GZy;x6^9qZ_wK*_JVwOIBU!DR{(lL1TOi_tZUAEN>P|#(t2?D z1bKV|Kqe|og#~#g@SZsGY2Y$|P6!E{+aDxb~pQia;MzO27_=odM^-O`tkqPp;Ta7sE+On@8bBw&7#cS0OrPc+i zBhdO1dHMYS0ej`J`jSr4z>gofIL71 zT`<3t|9Svp-zk^iyJlnz89yT3i{_$~GaoWiCUfa@n5OnoKF7#x5z-4lb}}C1a@T=~ z>QX$&5^~UJ9AI1|*?^}*m#Sw?;&M1`3fMIIKp&vX$b!!)vK%G1BZf~!AaSY#h^OW% zzY7?|LZ1`MOjiK)k<`cN!sJ@@$ndd|X|nJ^*1Cz)ocatAQiQV0ci*RK#XmLvNP7h) z0M_pI3K>40rN*fysc=r9plmfBTOKnGP&;4U+=&gS;Yc_@NMl45Dl5v+iJ=kD#Gr@r z+3~DNCgy|e+J!cw@1Jgk&WB?RK>d_CpG72Ot3FUtbuln(NA-zDJ(8p-`Mwj=g&CXUCO@_1u%aMaE)YhU*o1gAN+ZuCU~YB71C9#p z5QYKd{UHp49B7`KPz0>PF)%g9zy!y@;WKnLJLAIbL?#F1e-3D7z}pkQm~;eB>J(68!q;{gd3P8iAN@H()Pa04oiMADda2N7V+8eq z`gTPBl-Ioz*0v#Kk`6@{wEf6gS!36WhVqD~v=~BqWtYpi3laC_z&t=jK7;lWl-`xe z1oX0@`-htI@I)kBr=2pS2sGv53Fm}PZYffvBXJHo5>U%`a*L2_A@?kD0}jYcdj)dA zIkQh9*Kq{a9mzsugULh#NskFuQGi@R7BSNF*g!4~tlVhj&Zh}B$;(ALoFsW$%BJ&K zhP>w&SfG~6iN8d&_Nfx;od(qyi?5oVFbvO!m`~fn`dvY7>y`s8*l1U`8p!#5o75t} zKT)S!4O#rKyN1=Y#-5}i->&c^%2m_Y`0D5&ycf51btdjOp*-l;LfLvcdj`e#PG^Tl zR;n^z*a2L?XD`|bTtG>8F5&4YMDsc5v*q_5mzs-zcjDDaLH zp`7o1!kHKB}R9VaV< zQS81L>;v7_s;^)azxfpVkB9lm6EL}u-Xs~hkp2vhl$R;9(uFkft?YGyf;9@5?|Qfl zCL|F%T5+r3FW5z7D)D1*`+-pdER0xU8$B2(j%8znlYt$f0s<;ZH(49Q$VJtI3BWhB z|BB?C0+!4+Qd{I?x@|XJGewmFwyI*?nAD)hUL7d0c6$_DKl{TMvX_jMjhG+R5(T1C zY{W_@(f;jEvmPN1r;``4noU*JYN_Cg2I_3!{=nOGWi2qhq_bODi@akIYsP}D7cOF{ z>8cW}Xc_vXxn~$=l|jnS7XeJH@t<1+rU^)cZ=Yv#ycBT~ClK;f?;z}>1evykCHQYD z1QQzJ=Wryk{Ltou`6O|%h$%IFDchP#WhpqM`qWULQtU@0A=~s0^54CTg&9s8(z6`Q zohRg$<-nK+`M+KseC0>(OD|Ba-2DPO94LRq3b4JNkRw*G%rI(*t4_%^D_E&6@`(KW zCDs{5(pNe~V2w-tzI`RjAvkk<6+qwBSOc;~~8d|Hk`NHVrG7wq$^7LvPZ#@Yu zFl|5QW3glHnRD=f5;&CeJ_vUS`wXSM!E8(|Wn)G5pX|7nWhUiAj;To=wV)b`WwRpI_IC}SkZxdd5vvclLVoGs$w_@zTEw#d@Ph@#!Saz# z`4+`2J$wZX=ZqXu%xVNixJ{4HKdG4AX~ZgyDhEm8f#x~N`sIaJ*c6aZlh%P)M1+oY zioy2YI?yTw(kNl1d68TK$$5e7T*7L?GX$+l{%keVh4eV$vX?PE)8NrWlEYSvOKn4J zYP}8fOW51hmBuW{5M}?jNf_}tcIi)Y#H&Fz8lhjEz($)1nER4^=2hlP2jD|x;B#ws z6LilAmn!{u}W?p=1nl;WR0ZxN6Xg&IXQZf*{mfwK&)gE|lZf zv&J_}1FOo8(p)vgQI8A+_W{!22BQt2D$;&&8cL}UeI^)f#2u~#>;M8)xoQ@mIXd*~ zdc`D4@w3aCp#P}H2?#{|E~i;Ac@&4-Bz_tVDH|Zl`>K4%&u(N+kfG!9fFA&Mm;Biu z$~mffxpXXr`vRwzRH?jj16W6omnzoLiqg;ziJz?R47!!RE@d~E=xz56tSHdpF`4=r zt4{b*VBjjJ0ajhp`DAit5|1($o&y1F@SjK;g(#tM%`$R^cuYS2n!_>*?*=k9lx0LH zRDs<28mrNaY9ft4a!weiswxW!R&uezZ1@H@$#4o0Nz_5IB-s`LgxK_7~ zVBYSO{*CM%JRW}oVxFDy=Qr45JQi*usgnG06Wc@R*!DNseNhDmvA!+say+1V*{2K} z9a>{$tRM7x-z;M{n;G!RPM(qA&)Vb0<*E#W(v4p5z5(gAngGv8+4U{9jgYJ8tt=zz z!U5D-&Ca7b=g3Z5SyEk+d?@GurmfcAgKC037lf3f{^z#ypOuepW!-ZMk!ef(!$iYR znaBGj*es+vWsFc;-WT4=P0nR1%T*RJ|GJ3#FN&n1CGDFY+|Nt2B!|BZZ01sphyO** zs5s)Ui?F{g!bc?k@l42=cmAM%;;(Ct{Ocl7e_bT{Py4qC{fnwHfAaG`>T>K~Hx~ET zMXLREk@!FDa{jx2Fr^89U321J7fJf-A~pWBf1S4dLH}z0bJv7Gp0)P@T;D85?PEm=vk)BLU#BGf^> z1vd<(2Oq%v7s#mxz`!n$YY(uL8vD=)>9D9KlhVkn7!*weR8x-~VCTZ|F&dRe53=qF zzpouvX^HH3NL4!GkgD{lLo7Z12*v@OIj}{sv>9Zb?mZ&69fG8Fr~Kv+t2vDJ3Yyg} z%SaDEZ64dz8>2(`1oS>q*hfCc6?BHgsCoE>B`cx~MU6WdWfy0Z>kRp?&sb};Rrnb+ zf+|!xMWU19ZXn z$JkHUNvDr9i3X;eV0XAK>g1vMl zsiNuYxt6}3(NLB);n@36jB*@1G zu?tY7GUaH~|8`m--NPq~>ayb*sO%NUfoH(VDV9^tuqtk*RB*QtH&gIhvPf<}!?s(> z%@l+gI6{SIS-cIa7aTg+9+P7!Hzop%QSvs0Oc2P(Bq6DfIIE;MQt27^mik)b|+{yWwSBR=yT3%F!5iSpsvc8$7CsFHm7JLdCW|2?3g0H>dv#zu{VkHaHl zSgL&a2iBxMb`%hEFKJ@L_yQ)c@YnPJJ-+9D7*>z6%csmdFDI_01;cio)j%z!J*& z_sT&(u{t@k-RKVU&PLD$O~a7iVI_2c2NUNfykygeC_00Z{{UcFY2j`Fa_nDV!w7;0c)<*`lwk)xuFn%BS}<_^#sFcBq*hAjvxbAyj*{t z`G%tVX^sAyc1)$eO=wxE zAvOP*wdfi$B*?qSmK`G^GGe5{*~#xG+$)3ja7IQdTF%I#uo0tFO{;!psRLqr@!Ky1?uNY+1Mu zBZtjlHPge$Gbx7`P&w`byPO1hG5TFhO^}YR{z3nsTI>gLB*a{pVaH7=1XEx(*{S!V zFq%+C`bayXB=n5tcO;mMw9}v>2u2FL$VQU~HkuSF4>Dp5JQx7J`544NK6kHlSFlxx zG<@zWb=CBnsu?u``w!puKu6RB^dOhpF~SQ9>ds%-GvpWo$Bae|z__C<=$%SItgWHx zjg<*7OL3h}lAV5KtNZF2sBgXz_V=4YYJhmZA~cN_j)kTHdJl%C_imD{egpA6$$#x{ zthy0WGioYD^A5G8`dU=k9o5$rq3OcPgwxmg>-mp>32O}A5ZX?k8vMFi3IrH-riKLu zG%OV?ApI%8g1#od=OX&@U6T`i`HjhY1In~^^Wo-%#qw!4SEhZxy7|S#V-pWA1ol_% z;j4*3_gFY5E?mn9PF%Q~BKUr!+Ax*Mp3XbVEAQY@{0~yflUetD)?th5_k@Vo|?#ORa4w6@|R0q zg$mW@^2$VhB7Eyp3ejkn#E0WXS(L=)gsFrb%}yPtomc z32ox+@0)UZ_t~^`dAKgGjbgvn<%39Jc2GUO0}7xS_4(srh_)LUCI@Ho#)#nhQGGrE zF9v1urbtcGkJmH#U{%Zr6zi46d#fBXkn>I!A6>P~T@84DqfnMM;KX(bZ^+%m7PcDk zhwzx(2nVi07B%AEBlUb^mHMzTKM=1D8?F$2>hup;b{W4iE%zw4qsKeT0+TJ8*oQ7S zy=?2!5fL#%ugL5sJSp`TV#2|jJ>J9kArLVU@7L1{Aur43Nk);(ZNig{FXb~$ctbNk zR>oxW8sT4>D8Xf66JF2E)p;nAmCb9(Db0AS?9`N7$hak&X9M$W(p1&(GG0gTA%TWl zuiDvas8^lx9~Zp)0P>P7Qz<-$sot2m@iMz9uYsz2H|1BDClAZnO#xG8 z$XA>4SIx;s<)~&nxskHO%~oOv`scAfJyb^gB+xRd<4SyS87>nSY^7gm#z`4xe>2{~ z%-7Xl6X=jvtH`1oh&E2BJ4vCiR{}Hus4{@z@An)9?)^9ad+@*ojt;a*B<>oG*V^g;UW%S~6#gUR(Jh$+~S`BYk7)q+n* zrQ%uce8g?Q?a6w1z=p%E9jr`#+kz*;Jc+mD3*zQeLuZ|rq6?W^6}RN^#(e)fEwQ5@ zdWFpa(Q->p=~6QgxTDTJyo4LU`nrqg(Tu!od9q`O_z$XH9pBxiNnwmTfE993<*Ys%s6`7CoXNb2_dJgg#4b%1t$ffOBi2gigL z;TzDGfgO1-b5V(Wwj;j*kmg)RUc1r(#pf@DA&f{ToEH_mHUoipaX_($^$B6=E-bg( z@hGuJ&hCWWU*LbW6Hg$w-#f10HR|TWW4PVG-WYToUeyn{OU&eEgzR5orO4b03-JWI z@@kbr&E8!(1%|z&EB_0j=F+Z!^K0a$t~|-y=#ii$Z_JTqH=bQpHc7HS zrJu`y^h0{6+5f+nP$oL%AWd?U#5f=}^}p1Ozode+x}i)5U_0lnZ&fd?$|i^R#B8pSQ+o270Beu;-Zkr?F|R<8$EbV8O-;&+Y|yRfy7}S;U z5CjV+)6S@U!|+^HrQAGRp`Tw4=gZOcnK$#ZoJNB!R5_sMZ{fan8>a$bLoFKUBe1c~ z_IxOLj)(LLkRPZ15H`5d(*{3*NG7lt$l-;Xu9xBkxAMgB)f4gkFiJgmEQ*> zw&YfR2i@z3a(G91!|i+~HqMFL33v6!+`*qSuz}Y7i<8y<=m&W3tP0XKfkRZ&i(e*q zV2xcAUDv{I_$@#lDPTbzphDh$C;tIo4Ze%dYoNXYZE^8uq*SFpBV1H{R$~N!YOyRI z&wm|MO4I4H_t7Lei}JlkFN&T=;-Pu$txn$WX5aaKMQ}NES^45fo>lF8g`A=W3Y zpi8vS|HVk&gC?Wl-9V-){5Raq8yPw2AgIBrAeU|_co@K$L10qEV8brMPayO7h0bp= z&CdFdPEff4Jyy`ZSO-#%Lew`n@iPJr-wfsOE(&=Ek!LDhH3L*IX{8zVv5-7ci-S&@ zVOIo0V4@T7n-ATy;nbfjb1$i(k*7RMH`jS2C|Iz{oLa$Ff~VPF647lCW+Irx@zoxz zY162hhZ7#Fe&wU$=p>9%yXu4ajVYhIm#5XN)Qy9$J1^CRk7+yjqU7Owc@sB8i86jP zZ4}Lu3kzb52drEChgzPRIA_YNz?AJJWli{EO@n1Y8h3X_(NatV zP4&gINUE%rK7`dIQYabaXE=xS>cuQbAQ|3N4yK=U_C78U{yB(+%Y8F~cRx{)PVhHz4PreDgsd;{SWNBga?5o!=?RdF%k(35Ej< zfjhqoM)*6`xDdD#P>s9hVg8Ewid)XQ!Ag{=kMQY0jaNRxZ->_@@1tNZ03m*q-;YQA z$8asaC!c+c9|33v&!N5l^~ZUd1GCGK_j0acH2_?9mZPWhmGY-Mc)I*z0+&X<|B;D& zsXMy}!5!`9_OW1$$L}elzP$(>0u5TLVq>!JluG`=UR_A8oWhstE{yeWn#y}ZQYIs& ztE&QR4hWle%1twP2Rts!08#Sk%E=-UOja>t@rKKVuyum_{zQA2Q>G6Pf;e7Yell&U&uLiSuJ=nQjH5+V+ zHS)vRyc;qT^LaW6f`F(t0v`^KOsMvoMB#)(5Oj4u|FJqMH_!s=RTf)ryhLw?&H;9{ zMlPL$=%)qp!#TYEAUXifO+j1}8XI!J?DbYKvR#NIEt&mjC z1-7I~2%0nT@`I;1**ac67f4tYCXhSG1lll<9}KTJjxDj+|IBB}@7j7xLP1(Afd95=Pcv9vf=U-c|CGh5Uwg zC!gN}EQoGz>Rl+=3Ky6oZ1RqB96N(#g~~rL)Rz?JiGlMp@@c-W-YOz#eb5vF6HPaO zHKZS%M=IY)WEzq$O*&?jf)_$Qdu{p?qKozpCyJa^E{EvKMehl}G;LKeSm~9u0w1mHtwK4KjRMM} z_!01v56Lyp@%q#*)Bp*mJ%l9i@v!B5en9Z3bd4|$P#r6u=beC-pL(7@QC0Bx@Qb)n zpx3t>lwiI*{31VV?2zRv__JV>-1`#08;?UT@xFL8Sjh+W2*z2WyAF5eNZag(O$1ED zb}O%M`YOik5oL(oP2uPdJ@;0??FURaN7#p-lUrBvx#THu6(<)|Q&$1pRLFy?_>B>c zi$57(gpO^LyRL{zmpMgTByQa1@+mw3G!pJ`a2jYwpO#CDcv>I4M1OQ-mc4-l9U`|q zeoVUQJq>0d4lT?Hum{E}pLIS1$5`PNw(|w#xb}{X5-ugL@KS4p@!RG2g@1B*F|W}| z*X$$1c9g^msz80Ne$nAMrpxpL+;Z7jP-(VTzb1={d3J5*W8gGSAJm7s6*T*6F;DEI z%cPq)tza`fFfQFq5$Wu$$fv=e=a>Z8VvMmjz6Mk;9h%?z%u?3s4f2{-`1MeIUh@iX zDDaJ)L;b7RD8G1xXT@*87vz`O?2PIWHXBi3H%i|+u=uDbes@~O-%O$375InwB$0}m zB3G0PAC;(z8LT<%$qySG^Wu%4IwnOc1%`B;fDRBGWtrPbN`c%_S>%f&q^_%|vWt9Ls4Q4{swX+EsN}qbzPdzvid_dDT=hO^ivSxsMV>cy zD>YD+aOrA8d2>!ypvBNv^y%NgwtM+ae)T1%KT~7L7qKWq2CQ^ehzWWB8y7Jl_c#-$ z{B&q0Bs_LFOvvi8*(RP2OoW_xz_S7>7`+K7&i|hI=xh)$A0tF998kb^isr2&dlPTY z&L;-laS?b+o<(itWpp1rmD;PxT`Aty*WZ$8$yQ<}5f4TSvro^>x@zU^p3N4V;wgNH~$WdFhyr@v+`k&qk1YI+Fe|nqO z3^Q;mejDaL%$|3@ zAwS-M3$$2<@8s?L!`=fPO1?2sR=f2L7JKvq-mZqyqX2~o0uS&mRB5LC13pyt-p=zX z{Uh(+&X1v?s_n`Tc7Q3ZnwwBrboNfZ-(lx!hs@(X;8*;4YlX&V{xQ42Nh9wn=x*g5 z>P0N_0k+V2=$UHLIM zd`d9bK<0nUpVrbr4)=>MgXnJ)*bBHsSURAnrIX+nOEFkf3H1-@^bEu@ zRK&VnG$|@j1fS%-A-((fVfffPyN@pcew_a)AD9Hb7&aulDbb_Sh3#qi^QXKQ%68ii z;pk5J^?rUEZleJQz`0*8#~k2ak{3aa`B7d3z2rsE^x;8X1S7~L-~$ICyW1q+KFHU? zdEotrh{sppKlm9Ktw=XN!t+hM-g=aO1d`zCFL<(vseAP}))7jN$9e6`oE?l4LvDAR zlhq!#y)rECuEJaZsRA1kJUwucPw*D_^uZHE`^&{Al!#%|2|mR9)h$!L?+g5OzUCvV;F@5JqR_Jy3fKIsf)5Dbn%WC$ zo717V=Ch|c1@&xo2E~eH-WmROjmgUZ%aL>^WclJ&UbuQ_`D)@YR-MfM}<$;zejw}H=zBDA9#B5 zM~d_XT?gtY6TEsn8j-vXc=hlfcxwVZL}rl7VKN1vEm9y?<4bCw{0H79;Uh&mnb1cB z5@{$hktn*!x6%!Vv>G9)V?N8HzYjT*B;)^Zb*}^9UnyE@@%`B@ZY4j0HafznUvc zf9CCS;Cl{XmuNh|*)KQy;<3ib12TYU4LYyL$pap*z$%q{)yczb1z5IHJ6oD8DfM1>)W65can2*9WT zJXfSRmG*^?@RmwpT6Y4_j595=(>P&TTk%-sw#ZH+(_>v@l=>g@SoPdFdkdg%p*&UN z1fi;u`DCs{0%uYlBXL9F0;k0D5oSb=K}PRT?n?J$xPshqx1CDX-5ye&zz#LNTW}$2 zbw)gH!@S@z9J*Y13`u7i=8&KRp~5{`=BQRQCo~j~Ju}D@2U<%R@E}j@bVYoC&*QN# zxGFQi90e<{GJ}-MA~9KD?US&zBW%xDsGMQ>Eq7-Vv!JY{>2e`3 z1|B{QRBb!lI7-!yC@Ivbqy%_{INKzUAf8KnU}(fPK{}-}4F-paUFXaN$!8i-1F9}( z-l;PH?#I>S4?)u!wxic*&zWWqxg@|Sw9cOvEajl{=wZk_Qbko~`gdz_(Q08lSU^2n zZgeso?qvpGQQ>kzHv)e%YB4ZY^al5g;)~%&S6>d!1EG3o)w_Y_6kLU`)t-UxFvTD= zmC2K8B8@BfK~=zx@N%%#u*5nr2Ogu5Lgt-1^ET9l%;A8Fs=7$9RUXAFtm-KJ7=jW9 z?*vohyg}8{7^rBKNzy$g`Ht4g#Gwcd&_ix?AZH+5QT*#X694EluB0uZhl4XZGM$ls zI1?6*yio%9hnOcCuO6pb9FP3)Vdy)QK6gf>G-$i=_8^iEI z^OJTMK*u>*+|06L0hYm2v@qkuLbJ<`%h(hv8MoWFms>T>gA3&6ZB=qkl2zTz{a&VJ zsHD-!$};CkxjDrmCvkH!Ag$lg%36op`sTXU4I=LtF0YBuMg|WxwxyNIztvrU{_@fU zE54JGfzlQ0{9qUTP=3Y8bB5+2(E#w%?vkW1TH#s9=Or7VoG=2W}HVoKjavxdx$w;KG7>uDCre`=`a1h?9_36~hFm)ava zqFw*Q)w$%4$G7Bf9$$+2{Xe%`kNwGRJ@$9+R&(+{H_-q5$w2?}w-0p3KZXg(Ngb@G zB16$2nby(j{Wo4C=E;9-aOTf{vWh?d?W=fh!9Re{`hB+b4m4u?Uv{xt8rF3A7K8<` z3g79k*VTH^-3%OU7=mej16jDm2>aObEu!OL^tH|;L9Id=^nfiyOm+^=6C7!R{r6r!iwt^t^|#0z zWmJEwO|`ki2!Lxm31!C+c`r8OFl>I1BecqJ11 zaM^X%Fx(@j7cCa=#vE-DRAYzYVfBBenT@i~Q!cyVg1#M(q7F@}iGV zk{s)d)F1otG3@t)pB=y6dI2g|GjFi=o9~6o34`Hr`tcjBro<#K8e)+HfI~y9_7TK| zFucD=-%u-~kz$d8Tc>q(T;5*{OcMFxC(U!nDiL*r^1%25Lw58~>oHwfinMOB1b*Li zvz5q#1zO$|C_t?pxyi~je=%hCLomPh4YMe4Sd(E^b%|Ih7$}Mp-?gb9G*clXu%F>%I=l zdv*a(^2JQ)LII+D7KCQ>&()<<-lOSW8=84OgTh7i903j${DiJakIs7$+TX}LwOq#E zjm0jKZSS_0bkH%RX0AmfCk4tD;g_9ZmjyG*DI?APK9GTl`OsxgRxzPu!adg7aQgWz z`~lr#rGVpe@*eBqoG+DhkU+=|RgkRs!Mp|InUNx%FKmr3dWtXRQD3AKbR4xHyHXrZ%8|BGlq9`LyQmfZd%qBYPtHP|tz_CN`lgnV zmr`Cn{mZ3)JEjB5d?AxYTiN^!gL(|)G~47=qpim2N0qKVDXbwcPieVzCWGCuhVGtF zQuH8zcHwC2G8pXa8f{f?m~W+n3yJT+!h4#yx!Prv@<>R0<`CaZGG>g`2L7pfjjHrVnN-6|yA#62vTGS3jDff66$q&X@Jy9%itks>A15|*LFe(`Cg&TcT9p+tP zk#_yLc}_Nk&n)O>P8$}0RNy%E3ioo?>hntjI>z6LdbU6 zPmu)!Za)H%*hcc;SSt=AJ~P%zY&hpnM@+Y=Zo+`;siyZ?wN!9WnnBb439icQT><~J zyIfw#l%QdSEP&o|_gSskPKtnQc;A&J_gM`Pg75HsRx{{(#*MQ`N$A>f*3j^6I&47c zIItQ|$ur}ux`C|Z`>onqU77j-KhCJ>l1#NrBHgw zz@C|pSYsJgsajt4h}AwGA%w9r&2|R)c!UOXnG2dl|9-@(8z{HHpZX}coB>UYj~}CJ z)PMdlYm@g%0o)l~LG zka|UG=_E#b|!}SN8_0J z-;QHum2q4`M?Nr)N{zSwqn=ymd~3W>O}R57P!GK}?d#|*|Moe+fhym)gKuQTQ&y(( zfaI4o=30ly(NCD{J%nkbo% z9k3~sKP|R~M9%^&$6X20U3!@JYkBLlR_j`e=E1%uOlhmb!vv|506rV`a%95=W$Cll z9XRwf50N;I^_N(;2JIB(Q%gYBY?IrTSoK)2M?WqB2Czn^6k24f*}Bl`95`WTck81# zr4X{@8S+4()r-v7>n*hwB3ZUnoy>nP)wvy(S-HsFv`pomU53N+l#F}Mx(+A)uIH@d zfh7a5NtO34$HErKlI2w(&e7%8K4sNNbB{^K#fjMmoK|3E3qE-21qHm;zhLdAJrW6r zPfxyR9W@rpF)OTrktN#0WhTO&&V`b(^?IPtoR_TSVNc*%e@nJq3FxDL&R=P*aenq# zW!<5EE|#yXvND|91FNhS5zrZ;pb-ePZQY`a_#azs6$STT^Ox18y8dM#?F4R}EjMee z+HxD$(p&lYTI)7g=|SX3Mp?3dk+s;Ixk!Ff1Uw1m`Nh_?QG1`+LXi?}pVDO=Rc!Uh zDy1w^@*+U%RT~5#3{FrmDFC=$R9LPnJXmZkFwZ_C$Gu{uSBIF8OfIyvTbB#)tAfnVixyLi{(z&V;=->p*w+`y75Yc-+7A~n3LU$tmm zs;^h;(q_H&8B$69Dn+~dt+$YCm0Dz`)LcJ?lv*z$<=Fs{WP!YFgEi5ZFN-%=PXMcF z^_tbmoZ^w=U$gFqvhnHHtY?us>vd}YG>|@f9bSEokUz+`WY|W_hpc)Vt=ph{K4YUb zmMkBCeZ#sPyZp9I)>UlwAzUg9VdUS~WZi?AZuF+rCw>lX6Xzn;V#{)u?6(Dtt@ayb zxHS=lHhZg;8eVi5%`BGJZnZYatF}PPVvX}2QHbgNiq$wEi~V@t!}RLuf_Vh=ONd&R zJ9k?(Ft#suTf5}^cdc&N+Ro-s_KRtz?GkV@I{F2xw#N-qE`y<<^8& z2MyBhgWXHK@_|9W;7=2MAzTSYH2}lTJD`y2or+rQ-(QYH8^Bk#>{bT|^Ta~&6&#?t zvesVkN(v-SQBAANgaWpYX3F1pua##c%>+>aqy(B8c)&~77^UWkqhIln^?2-2a@!3p zE(5dhFI9XeLx4 z*M5%0TP|B4weE#l%n;bo-9 z0A0QlR&&##+;F?fWhbpnhjKHCsbv!7hTZ5>bVoyXCLCLtpxi1>T9?_=^eYwojZk;E zt^-X4LJqe%sqc7*kaIg!jGO$$Urfji{tC3mF8S0~R@*2=w3(#CVS;G;6j@hm^2{Xi z3{|F>opB05)R_)>MpYAeMpYB#<^9A%3tgo}3ecPWsyF$oJ{!WoeKZ(}#z?wju{r09F{}ewd&ZO&z}Qk%}n65H$^U;4|V?Doc4% zB+~X&1hWn5jIucmCE_|)Sc4l^`l-<&AMCuNpeH$bQcD5*W%08EnR81*?Rpl3*)KJXP$ z4|H(sA1lg$xgnV1!{1mP;to)~6zmEWNvg<_Ip0{VqYkUzPQHvjZ6(zHkAc@%a_BrK zrn~LLE2GHz1D(e?^!`V7Ic?Q3=Ny&)I&HN^yoJKkRxRT>x#_gksM>Qn;hYw=l zBC6;)`O9gmSJIate@JW8h3J*^P~EiW9+fwpu^J4VM-yeJUIUuOdR!<+W*cbk5Oq(p z0Q7IQQigW{vWGhsm`fzzLhi%qSg)2QfHV22}k>4~x{JZ0HrU6kj)JelXLRFv;|&YD_T z{=0L)f(vBtpMYq8B1iv(2)G;lUC&$hniLvQMQPlA0oXI8##|Sc7y&LMw$2GT@>eUD zGJT%NWQN@n1z&Mr$(Y|1mUa5Ki}8cB`5nYE?G}U(Xa^C1<{UsV5P?3jlOb+FM>Nvq z-(iT_hVi=m+Qjp9zvUKDluYu7bUfO5#3)2}UEvWA!g+@;OsqFfXbiKCyDX6+G*}_r10VyiAJ{v`!c0k5RYX zRm*raIph|L$?RysL2DA+pzAac8Wlc;^`%FAb7Gk20>}pR#BVa!OTne+d`QLBWj!Za zeBzKP{(EA?Y$HIk{C1h>A$!M)f*MWyQnC>sCCT=rg=JZI9AcvbU-EQpi&yjVii?)eRQ74o| zA?cPcGVQGk$P2P;njl)qRnHp;&7L8T&}TEMe74sJ`D~amOU_9UHSt)JAZmwE zeP?8Of@ll(SRxTG=E?er!56&~MHe;V8owKHt>29}<#!{ldC`bJN~96X)FknG`1i`L zR~|_c9mT;30IA3D&%0b^)etvV$(Ub53~l-Jg)%4VC@^DkE2uDOH=HWkOYsU%XfP9i zrHNWWg^B%8KUokp**95avOo>;(PWXFeDOz~%8!bYMa#M~V5dvhJh7rRdakfGjq-VC z0N#_ivQ<;GGYM;iyLw77;NGBJS zN-rCkaL+-0T%gZSZqL%AaU-O`H3=yJXQCP(!Ud{ohyw$hIW2~)G+b$hF9%*;(IN?h z@uculYb z!^i~OGZy|E>0(MFf)X^mHe4bUl-NOTSl$9O652&7#?DIsI!a@B+Kmj(J88fJ*bs!J zdcoR!9VP{2hT^fO5%mYFDzZXC7wFP}vjmli-7;2*KJZ3u8T0^RC9R}SE#$!MN6r2m z;NvvULNBhT4VHx#05XCw<(mYqSnwfDCTa}pqFj|A3uuYY9BC)rL%5+zRvGI8P5Z~=pp2#ix9Weozt zQ>%UxpCuc31X*#A=O7#@YL|wCvqr-~L=_B255REx4{)wFfYV1R6zJsWT39%`92?;Q zGZ%7Xga`Q=0;2t2cNjhgVA-J%AhgVsg(ZH_2%V7`dK_F~=h&gd6W9BK%p7n$oP7{! zvm9{DgZqFAdI9tCh)?&RXqe+%PD{u~;Mi0)j!gp}K3KtY!cMWTo#tu&RTGi4cxZxJ zh<6m`fx+Q594qM)ojpQ!%n<$R0tj>kEWp-jtwBNy0@MT$ut{o?fe;{sEXok$b7JX) zgW#jW?a^i=;*?@Vju85QB{9gC4c3Gf7rPQ?BE$QGX?E6sRA-R^F)E=d-`Y2-W(SpEJ zQDm?IxPyWVXy=p@h)qW*&|nf>kE`?@MIMN7`n+}_0ACI{1&5Ifj)*du!2_>>b&>HH z4rd%yf-xwAvVe~$C3aNaqtqMNm_-MBf|bDN2@DfTgY)mf>XBK517UH*FqKXME32TD zcAXU^eWQ7NPHUoUNJNRr9ik@NndZpKX(q%c&0{x8v#@O#0HXE|1-u(A1^YstxabrH z+cO-8T_KGcWV(U5R8W%oAsdY5R!*LQt>(E>BeoGO0eC%*uWZalmUbEC#^8eP zsgwt|z=|k(TgbDAqvEeOs8U=e8Zuz}R+&wJ+e}z3Rh?1|YiZKGWWh^kj9`j0k>EUK znVweis?>;THxXEc@e0Zj@qQ#=(g~lz+LaW*19&N}O7KADyZV|Sz<`4kxFx6@K?gj7 z&_NDA!4qy!yi42@TGa;K{T-aZH<9pVuiyltXAl4;IHB57aKdS;Dx8RwXX*np4wF1n zWZ3X%L)gI(=K{fD*LOaF__Q#L13x@~+jzir4Xqf!7qvor4AT8Dc~7ROpM{{Pw83DZ z9FKiZ*IRHCV7T#$3qW^XHMuDh7?DSQlqvec%9}0>4DmNZHp&9Rh66*eUip2;_23H| zX=kdt!Xt-giB#}i<%BFTlAfotf+T_jiO@!_Z7lMjW;Ls!*j$BLc&3r~D3Cz~{V3Qw zl%N=qjME>(qT{*EMK%=LikoAE#d2qJQL7GWa0pr4XSO0;9^sgG(QE;A<| zkR4ixJ5bB=7UF?=zawgcq-;{a{t8CPMAO!iLt6?FvtI~Y6&O2hH1B@@gUB?%%${_) zxVlm_c8zzg|MSZQ-1Qd7k6R0+l;>y&K*W$H>$VZoEamZnTtAh_(l%lZir&#yG*Eb&8pWg=M(+yo~E2`eHJMbrB;l8Si%y{h~|H zY}V{P#F+)Vr0x}>D=Hsxg{a&56FMPuWvh563Rrl-g13`2Gr(a|I)-nXT_O$UlWO0- zdxdD)3bRamuu|rQd-mjJ><+q|z&fDIY1?;{f%PZ9hO~B&hLvv;NwP;*5#7w;69gw$ zTe(H68MQ0k11)zzh(PjFO3JBS#ZF_gytbR@5;*}F6Cp{biMLdvTP4NW zrz$IZvX5wv9&OQ&ANznRtdPz6f@x48XZID4;t|Lx)>Pz1R4D{caxZJ*qJlek0qWW#O_?mar# zU5A0U0L9s1nC=oOhKpN~x_3CX!i~3!JB?ibTepLm>#a~uImj#91@+4x|1V@?yIpsu zXcP+}Uj*)dpfW&CAh$ax=iVtg)<1$B5$XLJ0i8&JN4Z$RKw4mdPP+#km?mGpS0u|?_X;a{8iI1+ zjz^#D=n)_fs1y+(Fx;JekEmgO5>nWA$->0&pew|l_^Rx2ujoQe0_sweE^1QVE9&Sb zeesv7K%V)l0zF2Hr^B8HC+jVFVzel7em*ls?AJg2504e!dBWa=LW5t9eNZe(d$p&p z#xjzlMEa_Carxq3gaWv|VmtU|Ku)@lr}k#!#eU;e8TAlO_M6gvNHjCv^pAT;Y%s%K zARe5**`ol{&hMp{{=BIXp*ng9_dYIbcZb_ixV; zEezx1^%KwrcIknM-~djOohON=0ey~8|2|+xPniU;QLtb#5F~hfoGeJZ3BD^S2uzy{ zpow^3lYzMv$oHzeYxjhDck>e>fuyC_#kesP4;BZJM4F^4GW!YjUYlil9as=v{d#^T|BXJnDq0QBAVh z_sN@EM^*EGo+n;1j1zLkba4wFr>Bb!#tX9147Bos95e$L3?it^5Oq?EY5B;Rg9#){ zaaZkJctHra%jnHp^2`h|(%C}8W{NUr3uVj_5flfd(Ual|JVrk$N+7tX{gJpqK0aHd zW{^HyV^=nK$m!VZ$JW_t&~q|7)6OqlXM+SL_amEUqc;_@Vz#>H;_?MWe1g3=MSR+m zFDMqm&-r4V3NK*;_i2+xA~iVMoo9)AeJGew6FScX;HG5>&XByb-;( zH9z3ILLFm!-$m)O7p3#&R4re4QMxpkCg~99f25)Cqg%xeyF+IeRAz@Mk(er+Tbb*j zL>DMVAZg+fUrgujrCf@n0qUE`3Y}Z#@HX&#@hft*;PAaL&7XTY~r#GJi@(s`BXGD<7#8x0pCpS&_1!P7ejsI;Ii+EfN- zgiv@@T%qv6uK8SJ84+e+o; z1!4oaQiA(e^!hnYY!Py$gh$Yo5<(?(i_)K~Ao1|7bV_2MmHML!aGz4m%2Tr%recI( zfb!Xeq7}uN!IFV{g?IkX7mD3x5|xhfiIGIV5H2tt9-9pE*tC6-Xc&8erwLULh6*ws zJ&af^ic|2Bnl$8M*BWEg*R&K^54m@-=n(f3AeYZo*Qf`V_7uJ5Mm<@kv*p~zj@elLaI@TaOnIcUbTPkks z7w{B8&Ucm69w;=`h-ffWBVtC=mdL;ZHb%;e1Y8atX6Ph2zXgbMK^O;AMWH(W8Oy|W z!+6y{XgO}4UO|mf#N~oFS&+ky-YB$4?L&BL*U}ken}DuYEdhpApuFFD0h0*y;K3IK z#GU^AFJiv~Al>njmx}=dRiZV*4)~X? z5$~HhiZrNHkUa_P5@81l$+AEhN_fD)(=-_^wXnAl`l-SWP&(4y7fe@m*o=VzaR~ju z2jnYWttm8IG%9LzlV2A>2$L_n7mJ}uSXBr8ROBQiI101foL*v;E8YgwS>gBx@H=fCFfF+5S|_?+^3zGF5Y7O9a~%8Pcu@`UU?Bu* zxTZwaFuO#M>+j7a;$1wZy(-=(A5!ROqR$MX&)60agP7Qb^4|53Im5r_dQsmzQX&28 zMIn;c`^7?B8UOZ+C(x_$rQ&*c#-g<*2f+j~!7srT;y+d@I4$An4WhYu_LQvi8ZOjg z+4nWk!#D5rW*6MYKw6HTwjeJ)gow7lMs{fJb*}-fT=b3qi`PUFRdV5Vq&I#g8*LOV zeT6z;OBm=fTh1&aJ}CIMA;DQDY!pMaLli<{L!BT~&?MR@XfVh;aa^XrJ4}FNFC+EJ zT5sU?&X@PSA+G8GJpz-QWm^H#mwtJ1Bm<-fKsc^FO^SGebLkv(W0R;JRdyUiHK4HO zCDhp@n#M0j7L*IIxgc7EI9(CScjC>Z2xXcwO(;Xu{wIWT{kltuOA;bf4<%UWT!X2K zsIn<|Crt>nmli?y4;Jt9 zqJl{IMq81X6J>iqlSBl`J8;~zR0rz|=AH?+OW=|cAWb7o3St2rNg~RY0fj!av(a5MuBXnQ;IWtM3p992*#Ra-WC+Nm=wYY711kI(`b67q>H8vR=D#D z^Oa>jO0P(!hyKBjm-EW>dCAclJe4Uii?1b0Uf;@1K_OL1FyWn&nENafymHinlS8#Q zp*;~IQGVE7)Nfg+iF>@(@yRM3^G)%Xp2scXKtWI|umx~ef%k-~aJl^Oeenji&g|{N zBAVps9U`L}9PnC*ghN0OH!qP6;Un$rd$9gs5@8L{VVZrgc65v{2cJN_#}1D#&OQ=t-tbTOOU%M>m@C`$jXgz6w6c zM59U{MZs0_Jjj6ZxBxTo(wAY@Ugvk*au9K3>R@dM!*YKHLxhZnO>ljVP7hZs+aw3mM%>KSw7 z&<{ZO1XfdGHGh!(%LQ{*R6bHJ_GF#LMZ;_c+J}&Bf;S#7IQXuNSfw-VzkLX|JU0-DG*ekAbikQ!t@|!)PU)3^{ zyK^u2G9~h+PlX@O%i-q?sEH!xWcq%nhgJBW-VZcB2N2nt6HdMZi6897aa80iR0K^0 zjzCOk%(dTLBbooLQA$%R?cn z&w#~oD3XLCRZygAW;`ziwE0LTEYu1t-he@Q)yxFm%jKWX)kJ(c3^&S8rKwOF@<&E~ zA`V~Nlls}qN(AePL^T2f2 zvH*Pc7Y8)U354&Wb^(>ZsrW&;%USd3XVWxGd|#u4QSw&5J<2B0y2@x z4chz@Qan1R9HGU#K{$dMIIsr`X&K$Q7h_Q5o0m!I^b<i&pWhyJtWXJQo3ffnf`4Jz~Y z@&2fAG!`4Y3w|i`nhmWCP@?|tqr6y!ObDCIy@E2w(0VcfGAbx@maN=x2w-m)jXmV; z*J#Sr_Bg?zHild`YloxiF`=4`3|LbYA6)0a9Xu6wIK!WK@>_QrnLl~Erj(yJ54dDe zs36l689MtX?=cMa8$T;x@!ih=77OW_!`@KJIaq$1QxMM|YXJjPY~A5X9gcW&jnBQo zXkJAw|M?ht`3UIfqeMqQ(SJ@K9f82>D3x+1&a^q=U5d+sqhPuA(w9fQbz=5m6j%?s zk1ibb)>ibrqTAp{?g4`zaKJ0K=`WC>9i_p)K#PW&IrS^;`NiAGvw@w28~R63&N1bD z(eD@pkDCz^*!v_dl{_+tj(a%(@69Iw(vH#e6W(^Xl%DXm(x<#b)lNe2e2luB^meT~ zW$Ja96Oe|_<~sNu$6PAhJ;01&;T~IDxvj$|=;M>#Zg|ai%KNly93;(j;a7b2F`9D< zrlaHN(kbutNOkztI~bSszj}M(lKPvsi+l85z~@h?|8I)5IrW=2ADXc`zbiE%R$fZ& z3e|%04~bAMR3`67{O)b2&pJfQfA{vXPjJE>@za3=-bM*mR}o^VX3((H&`j>4Wv9LQ zY{;i8$pGkgI(yoCOH<@j@EMR>?EeHRadV30lExOCMQRNuF^Dyj!fTL*{^3oCsaSN= z|A4};gpU2;&ETLnsIgq%iCC4XXS{XTH_d9AStI6_bo1~pu+qj2WDu|4<4bCZ7T7BQ z+8o7BSbPO9SnKYJZ?rXX%UMXWC$#B|_eou!vxeH8^QK%=YHbn?ki#49GiNbL65rn( zI~x0jjb|eE&A4;kJE}tc333E|V3=WVmOsvUvohXvw|5{GD0B7vIIIqwI~gLzJ=FBP zx1TnOW}NpX)>z4+SN4BJ(9i+k%+8i)fKGxBkooH<`u@DPe#$5q+j4ynXT*1dS&qka zG7XH!feYS7iRG_ZCG2{r-vubLM$y^}-fF!^LCO!=AgW>V$62W{M4OFh+R?p3AhtW7 z_<>?fi=s(&A6W=s2{wA~ncCC24)mh=MQ?{bO68^${MZ;mzls3>j}pu0%8dX5pubQR zKE(yEAhy;pr$ET1HWu`4D&ao?{qBtAwCIvIGhW#V;45LG;jpSHUQThBylw5)S>4aA zBLFuG%PN@zgj-in6xZ_i*2hP-&I#3ek!n3y6=|LX)wrq!)&U1Ed5aruVVN-4JO36P zE3yb?24(|u9a|eH(N9siox`cH1;WD6$D6#*YU$%K#uhp4vf#VJc2U#(Z%%AyKruLR zhyg{w#5u;$CYIDuK|oW;DfR zv1a7qQmPrOUyaq(rLlGCqZ_wct^t^EXy^xk0b&jXlD#h=>1)9p1F)^RT)*h$tyjdY z#g(_VO7nm1c6i@&>aGI)WuR8X(SN=>rV-u=TU$q^P*#Qv~Kg!jj> zDC4$v;ij?DUHme>7;3+O8!un6Wggj8bU#1$e5TcTt+co^Kw>L4?&=kzpp(on<5@V*vNwyj|#H!b@5%IcO@6w%o;3l*@T8d}3n zS*Walx6%Z|NGm`CaMgmz$I#C?tUZh#z;tWoH|0rov^4i{(%`2toIK1)$w_vtG|zC- z!%4-$|HVl@nOk{MnnPbflC?ROb;Srys;WTuYt7BqIql=e;1F;|C?^Fc0irc?AtzN! zpoujliQpeJMtucTrGKoW;ldap-UR+cfE@K@Gbm9S+3`Cd3}p7&CTjx_slg3f8a?2p zGg}&~s=^+X$Db)?>$=B5Hy`sRwc2bQQFf6{C-E4kLR!xkC{YY@hO3+)tNUR^h=v9yM1pFKSdU5LC;z^q0>_(!X`kkX>+VsziJBL`(cxs3;Jf78d8gLKcEB z*4gm^e6a%p-ZY$M5OhQoz=5BPF#?f!7nNiS#uz9^sd2`~+En@>&KSi)ZACgOfkpVN zITmWaP{rV&Xo2y*coJ0&2}x^uRcyl&YF*X1S3mEh8C8t|zVpt?U<`g(sRE&N&}lyQ zz>jifywMzQ4~{q31gcJgv9aC+Q0gpgGnbr(YRs~-*G-t81cf;_GHb?Zs+MSU21Wfy zqR|umS)XXM$HkRo+>GJ6J;`W;%fuvuqxDxwHag;RXELU7Gc8Cq_;B~^6l0iv!AT2K zj27J*mUS| zU`4Sk-QZK5Yh)Nxaao^XJOlMcvueiU8mRX7svFPal|aDYGd~IgMr~Z?28`FMt8HF9 z8kPnp*~X+IHV9BIBA|qNW*W7)hJv7xAVy(T2h7o28fPre3}VB>`!{I3pk1JDH82H; zp;p7-xL&W-08F|-=V};310(TPia8oDE0hYr1m*}t@Bs7jW#=IOaGIQD;FT{x_2)F>AP+Ww z=0|X8K^z+p_62o}8{r|kxenIdEb`X{jj)WauWJN)RaD{P(ZJc_{aNt@u>`{)d>qb= zGyvIg0XF7wjIrzHZ{v3$C=|@kN3pvyC<+%Ml5i5t+oyFg?XS|GXsG51?vOh?Ab3g9 zff_ihh*((EsvZ`@I+|0@Xx|Bq!#TykH{+rjXX9ANi2bj|f<=Q^9`ZxbX%N{OrV)1J zKfv8`Jz7DKE!J0`u4@2V3eWy^~|yizR(2$C!bQGA-ArqrdH>>A6N4mE{`i ztkq>5^+t>98}+r>w6DHF+S<^w4U9W9ZFcDEJmYf>$M3v#jnRp{8x;fW_Wz51zQ*{8 zpEoj+H3S#LFhDVUys@zg!smHSP?bJUryCyjwMm4QM`yB|Wr$3u^Gy5aQEoG1jP)Xd zX_XB0C&ofPib;fz$4=VY%(w=28UB2uZG7eTL9hBz^RJy`Mre2oL(}kKBU>6@6dZSk z{beB(hZGJQ0=Olc7hyKnj6^aBqQg*=0MsgdBR`AJgx*03#*j!3MoC?FU`pNKbd)Su z?|>Bn+SCaE>Gn@ncVONeFgXc0PzXPVp-O=mPQz0clPXE7&Qk?Zvu%T(4l2+!0J;@4 z63C2(z#WULBivDVnjQX?PIy>B$;f9+Ko86^B(%rMDJSdeAz$L|h;Um_WBT43gbw)H zr;KiY*)gpB&{t^lVdFv9W~XqHI1`&qeU2C{YNA8zV8$(jiWD_x;P z6XdkN;+)gba{zQtlG)x^;NP_M6U(#5Lm6K=e zBn`X{m}F;Y&UHph&AT}o?iofv3S?4v&~tlF<4(p{B|VMz5?3-ud>Ixg-LOzR zaQ_F1?Oz#s>`r4jD+FubZE&P9j9hZ)hr5j%D~69Sd>cYv-D9NMV_4v7zIq0@w#xLCDpor*g(dV{Tj+scnlk{Y-vs!BT3FFbHl zoWQ9xexUIdbsJzr|A#Nk)M&y$WAcA4k@JMnsxJ#$1hyL=#;Ooy2AgLglX-BLnb6;y zu&dkylbvDA(UEE3+rr57*`49SP%|onk_}H7k6Azx3yxLT<{;xF2EO5w#v_>g$xj+@ zVJS3t${_A-O!<-zlA<}#<=DYRaS@AP6v?j zf5pKAoh)K^_|IUR>gX)!V@d&GVgTnH{!K8<;&vSVx!xckP%EoAYij@YhK2Y5Oc~>K zf7S@9KJY<o8+>sM-)Se;w$RpB0E@IWAtVE=1*rdm zk<2l7qo~11BPJ>Ab?;*JCuSI=1?noMZXK9(Su|x!FVJV8*GdHRI#z$c`DXHXC@mQP4d4n1NCU}<3`uWX;3aG zo!`a`ObG3K8*@(crx<)v@NZKZn}0V7@LwwWkx)GF_rn$lT8O6C~KO~dxU*f$4^0@VW!@D=2db-XW{_ghC2t24^^NMfc2gKn&D+@xpf7#sS`l-!ABN46RrKCERS2JG2a)2p38y2Xl!<8hLSF-ATBc}!`VQ~?_Lbw3z zmQ*Kj!mrNV-cGR#DmoJ%E(X7UyRTgq7&+IY9+opje5@IOttbndR35W5>cnPyC{&xt z;mTmdYFD-fmGPIcSgPX7rYr=z^29@B>5Kv# z5A4d0!g?^=QGd8s?161{3{qo1j|X;y^%XjXC2oqCwg^jMyP6Cd zzR2*0r}1wiXP5abqRdrR!tq5$j%~NkT43}5$Q$$J2*#qZhKto|9I)7^AK;me<<*E7 z4&nL4P5FG%ip7fNJg^x2;dVM_r81WwHHMlmF>2#u;8<$5vepdtRWS`(Vwl+$s8nd2 zaWR~nFUCUU!iyLCSy5d91(JVQ0s!~{wJgC16w#d}#;qOBh8;2RqW(fKYGe@j%#PO0 zt}?N8oN&Wwf7v+<|8K@N;Ls1JD&A71L%)?6o%O%5C!wy(jBo$WwS*dcghA1!P`{8d zpV;%5lV3pwkud&kbI4c7F87PTkV%HcWjSH;V zW{!#d);4`yi^z*GL^{q%_bnDHW}}UzreNt4Su!|@auJ2 zvB?Mqi*b(-QQxX8wk|Ax6Z;NQxC?H&w28GFp~jm*LF)@GF?O^6D={`=KZK>&Z7?;L zzcx~V5mL7p&9pB=J+>Gzy0$FTYn$;igX8PIHC(U{4RzjOtc}9ev)i~Qs`J%Y2pgI+ ze*z^}ISb(k!~wJaBTKQQRIwDtO2Lr*6H9UP0b^z*mg3R@AaI+dsQ;s4DQ^7{(#ayy z4;p-)^R)*tSo7$`gGL(TK|09vIq+aLMuCAcqcuLbPnl6up+Gf_mZH^0fuJrK1x_zB zvfJVeW!_-A$&lOm?9)LPYYxrN_-tiJfu4k(4iC<1gUr<{A$yR3GNb3&6hV zCnLQ81g82hrUM<%#i2~S1W|kycsWo=z_q5!IGw4z!%~PL@7W3$nlR< zM`@#+>9`()z#uV6yD07kF0{ua0Gaw#$#cc ziml}(X|2%h2GwRve0#35BMJ3l)N_|!- z^+l!BMozI-M!olSrPMc-O75tX+EppF`^SRF=J!>4c%V|MtWxS{PL((ROQqDwN+o}* z^z2NfXXk$Wq#&Z2OO+lL9*peTuu7?sl~Q9WrN)O-;q|a#2_Wwb{yEG)yYS=3diY&u z6Im)aW;_I{{-o>5!%jn(T0M?2^8-4?D zz8MX$41)d$7 z%nn)NRJG|Dq~Qo)$T}I4*n}$t<^xRQv7i!@YN`AT_*#?N^1D2>% zMPp$Z30lEupr4hySO6Po9aIVo9QHqFi7} zh0qs^QQ+253>Wy0Sp9;9IGg&b9^iwy2fWaDHdO$cioU30od3@{(Nmoj3|WV=i^K$S z%lxC#SSi*MrbGQ;QUT5Jojji?#tR?#u#WCw#kbS8l>%O3<9O1~7>}~;733Uj#H7L{ z9NtfbXRw<}=$$hl3x=1{@-s#~MXPcAMSK;HC8$_bZO$mA3ui#NmQc!{Mh$&+DYf}i zy?f`MP@3#2rQv@XnKcz@7h#@Nek8E%@uK1|&_>h%1?Y)Cp?tYW-On1`^iv+1c@|Rk zFKEqKu*@^**jYfBqhy{lGQvl7Ja7(!f0Ra@gO=|Y9Xe+WEKbirut{{l3%CCx+l8`zao;RPe;!NP&&2}S2$Ft(!T;EP6{ z2Svf&qsRvrElug(i=de{Q^!lj_qYW9GF}7qx8yJ54NaRl@mhh@#O;E$Nli4tyni1} z%(e8S6)s{Pv)C5PTLSt}OSNr7#)vLjBU{o1laosHF}CGD)5m|sioN9+1K^4QgynbU2H*0# zSFn=*DMMs}_?>8oBl=}06$3x~6gp|ETy^PjDLhUG!WYACAdO!0iSGKY6?DKSYVy_N7wLgrE3W0(1qj?ZfT10% z!UkG8YPR}upwxAKac!DiiX$AbxYjCV7kJk%dUACa{h~HsYsQJ2v_I+TI5CM$FfnH! zCgBg`%x(rRN{zAD@kyUMvK@}5s$l@&pO7w>!S0(x?W%}}Yck8KD=#_FJ>0d^ZvpKw z@dt5kRlo&@ce|4gd<2V#(kh~9!LlWoW`4!!Z_dKK|AdPL7p%zRfQ3MT=EqzF(fA^Z zK#mbvWD^%*0ZT+JkXS?(IUG^TF1sO*x1ds)Ke!AG%DI|w8UCJ#&Rn`mHIQFK78zTD zTHtLMSqqCZ%$fW^nchG|VZ8y{LH@)=5wCFS)6HDt6FC zH_c8J*>p>~;6oEWNf)Mm$wg5a;^9hS%&4#!6E`$GLlkPeLs8Yl5DiBt4XZBhk6H#P zK!|>+F21RzZaGSU!?x)MDZ%_ru~lYwK(xStA&Hsd8SQNvpDDWAA&Wp>G={A5aHi-g zI4qH+4Z9L@gh%UNnSY5onh8R()i-_IMQV5U|=wca4rEg%;tsTP?f7oj( z9=6T_CA%@RFyI?#eU@kh)bmFcI<D1vcvWd$~b@xJ=81UtGxnfid_

OLw!(0^K$OUcQhCMkxo)lA^F6IbJwNm8N4CW;e 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 J^JA;H{vQ|SKpp@9 diff --git a/web/workspace/src/lib/workspace/config-source/generated/types/ConfigSchemaContribution.ts b/web/workspace/src/lib/workspace/config-source/generated/types/ConfigSchemaContribution.ts index 69d5a595d..957a1a06a 100644 --- a/web/workspace/src/lib/workspace/config-source/generated/types/ConfigSchemaContribution.ts +++ b/web/workspace/src/lib/workspace/config-source/generated/types/ConfigSchemaContribution.ts @@ -1,4 +1,4 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. import type { ConfigProjectionValidator } from "./ConfigProjectionValidator"; -export type ConfigSchemaContribution = { provider_id: string, namespace: string, version: string, source: string, projection_validator?: ConfigProjectionValidator | null, source_digest: string, }; +export type ConfigSchemaContribution = { provider_id: string, namespace: string, version: string, source: string, authoring_source?: string | null, projection_validator?: ConfigProjectionValidator | null, source_digest: string, }; diff --git a/web/workspace/test/config-source/api.test.ts b/web/workspace/test/config-source/api.test.ts index d0269c215..6bded5f07 100644 --- a/web/workspace/test/config-source/api.test.ts +++ b/web/workspace/test/config-source/api.test.ts @@ -244,3 +244,41 @@ Deno.test("config source API surfaces bounded failed evaluation details", async } assert(message.includes("structured diagnostics")); }); + +Deno.test("config source API carries bounded optional authoring schemas without changing validation source", () => { + const body = withSchema("validation"); + const authoringSource = "shape\n".repeat(6000); + const contribution = { + ...body.contract.schema_bundle.contributions[0], + authoring_source: authoringSource, + }; + const withAuthoring = { + ...body, + contract: { + ...body.contract, + schema_bundle: { + ...body.contract.schema_bundle, + contributions: [contribution], + }, + }, + }; + const parsed = parseWorkspaceConfigTreeResponse(withAuthoring); + assertEquals( + parsed.contract.schema_bundle.contributions[0].authoring_source, + authoringSource, + ); + assertEquals(parsed.contract.schema_bundle.source, "validation"); + for (const invalid of [null, 42, {}, "é".repeat(4 * 1024 * 1024) + "x"]) { + assertThrows(() => + parseWorkspaceConfigTreeResponse({ + ...withAuthoring, + contract: { + ...body.contract, + schema_bundle: { + ...body.contract.schema_bundle, + contributions: [{ ...contribution, authoring_source: invalid }], + }, + }, + }), ConfigSourceApiError); + } +}); diff --git a/web/workspace/test/config-source/wasm-parity.test.ts b/web/workspace/test/config-source/wasm-parity.test.ts index 23449ea63..637299db7 100644 --- a/web/workspace/test/config-source/wasm-parity.test.ts +++ b/web/workspace/test/config-source/wasm-parity.test.ts @@ -381,3 +381,113 @@ Deno.test("generated WASM completes asserted WorkspaceConfigSchema keys", () => assertEquals(result.from, 2); assertEquals(result.items.some((item) => item.label === "profile"), true); }); + +Deno.test("generated WASM authors value-based Profiles using the Backend schema without materializing authoring fields", async () => { + const source = await Deno.readTextFile( + new URL( + "../../../../resources/config-schema/profile.dcdl", + import.meta.url, + ), + ); + const authoring_source = await Deno.readTextFile( + new URL( + "../../../../resources/config-schema/profile-authoring.dcdl", + import.meta.url, + ), + ); + const schema = compose_schema_bundle([{ + provider_id: "builtin:profile", + namespace: "profile", + version: "2", + source, + source_digest: await digestText(source), + authoring_source, + }]) as WorkspaceConfigSchemaBundle; + const content = + '{ profile = { entries = [{ selector = "project:alpha"; profile = {}; }]; }; } as WorkspaceConfigSchema'; + const tree: ConfigTreeSnapshot = { + revision: 8, + digest: "sha256:value-profile-tree", + entries: { + "main.dcdl": { + path: "main.dcdl", + content_type: "decodal", + content, + content_digest: await digestText(content), + }, + }, + }; + const valueContract = { + ...contract, + entrypoints: ["main.dcdl"], + schema_bundle: schema, + fingerprint: await toolchainFingerprint(["main.dcdl"], schema), + }; + set_snapshot(tree); + set_schema_bundle(schema); + const evaluated = evaluate_snapshot(tree, valueContract) as { + projections: Array< + { data_json: { profile: { entries: Array<{ profile: unknown }> } } } + >; + }; + assertEquals( + evaluated.projections[0].data_json.profile.entries[0].profile, + {}, + ); + for ( + const [body, token, label] of [ + [ + "{ profile = { entries = [{ sel }] } } as WorkspaceConfigSchema", + "sel", + "selector", + ], + [ + "{ profile = { entries = [{ pro }] } } as WorkspaceConfigSchema", + "pro", + "profile", + ], + [ + "{ profile = { entries = [{ profile = { wor } }] } } as WorkspaceConfigSchema", + "wor", + "worker", + ], + [ + "{ profile = { entries = [{ profile = { worker = { mo } } }] } } as WorkspaceConfigSchema", + "mo", + "mode", + ], + [ + "{ profile = { entries = [{ profile = { feature = { ta } } }] } } as WorkspaceConfigSchema", + "ta", + "task", + ], + ] + ) { + const cursor = body.lastIndexOf(token) + token.length; + const result = complete_current("main.dcdl", body, cursor, true) as { + from: number; + items: Array<{ label: string }>; + }; + assertEquals( + result.items.some((item) => item.label === label), + true, + label, + ); + assertEquals(result.from, cursor - token.length); + } + const invalidContent = content.replace("profile = {};", "profile = 42;"); + const invalid = { + ...tree, + entries: { + "main.dcdl": { ...tree.entries["main.dcdl"], content: invalidContent }, + }, + }; + const diagnostics = analyze_snapshot( + invalid, + "main.dcdl", + undefined, + ) as Array< + unknown + >; + assertEquals(diagnostics.length > 0, true); +});