@atmem/architect 0.0.0-stage → 0.2.0-alpha.4.1

package/src/atmem-tokens.css

@@ -0,0 +1,79 @@
+/* Generated from packages/tokens/src/tokens.json — do not edit by hand.
+   One definition per token; light and dark in a single light-dark() call. */
+:root {
+  color-scheme: light;
+  --color-bg: light-dark(#FAFBF9, #0D1011);
+  --color-card: light-dark(#FFFFFF, #0D1011);
+  --color-card-raised: light-dark(#F2F8F6, #151A1C);
+  --color-ink: light-dark(#172033, #F3F7F7);
+  --color-muted: light-dark(#5F6A7C, #A9BABC);
+  --color-line: light-dark(#E1E7EF, #687779);
+  --color-line-strong: light-dark(#7A8696, #7B8B8D);
+  --color-brand: light-dark(#1F777C, #5FD0D6);
+  --color-brand-text: light-dark(#1D7176, #5FD0D6);
+  --color-brand-soft: light-dark(#E8F5F2, #12343A);
+  --color-brand-ink: light-dark(#FFFFFF, #082729);
+  --color-good: light-dark(#166B45, #57C793);
+  --color-good-soft: light-dark(#E1F1E8, #123528);
+  --color-warn: light-dark(#8A5A00, #E0AC4B);
+  --color-warn-soft: light-dark(#F7EDD9, #382A10);
+  --color-bad: light-dark(#A62531, #F0808B);
+  --color-bad-soft: light-dark(#F8E4E6, #3A171C);
+  --color-unknown: light-dark(#5A616B, #9AA2AD);
+  --color-unknown-soft: light-dark(#ECEAE5, #22262D);
+  --color-signal: light-dark(#5B45C7, #A996FF);
+  --color-signal-soft: light-dark(#EAE5FA, #241D45);
+  --color-danger-action: light-dark(#8E1B25, #FF9AA3);
+  --type-family-sans: 'DM Sans', ui-sans-serif, system-ui, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+  --type-family-display: 'Manrope', 'DM Sans', ui-sans-serif, system-ui, -apple-system, 'Segoe UI', sans-serif;
+  --type-family-mono: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'Liberation Mono', monospace;
+  --type-display: clamp(2.2rem, 1.4rem + 3.2vw, 3.8rem);
+  --type-verdict: 1.6875rem;
+  --type-h2: clamp(1.25rem, 1.1rem + 0.6vw, 1.6rem);
+  --type-h3: 0.9375rem;
+  --type-body: 0.9375rem;
+  --type-body-lg: 1.0625rem;
+  --type-small: 0.8125rem;
+  --type-eyebrow: 0.65625rem;
+  --type-weight-regular: 400;
+  --type-weight-medium: 500;
+  --type-weight-semi: 600;
+  --type-weight-heavy: 800;
+  --type-leading-tight: 1.15;
+  --type-leading-body: 1.55;
+  --type-tracking-eyebrow: 0.08em;
+  --space-1: 0.25rem;
+  --space-2: 0.5rem;
+  --space-3: 0.75rem;
+  --space-4: 1rem;
+  --space-5: 1.5rem;
+  --space-6: 2rem;
+  --space-7: 3rem;
+  --space-8: 4.5rem;
+  --space-9: 6.5rem;
+  --radius-sm: 6px;
+  --radius-md: 10px;
+  --radius-lg: 16px;
+  --radius-pill: 999px;
+  --elevation-card: 0 1px 2px rgba(23, 32, 51, 0.04), 0 8px 24px rgba(23, 32, 51, 0.05);
+  --elevation-raised: 0 2px 4px rgba(23, 32, 51, 0.05), 0 20px 48px rgba(23, 32, 51, 0.09);
+  --motion-fast: 120ms;
+  --motion-medium: 220ms;
+  --motion-ease: cubic-bezier(0.2, 0.6, 0.3, 1);
+  --layout-measure: 68ch;
+  --layout-page: 1200px;
+}
+
+/* Light is the default; dark applies only when the visitor chooses it. */
+:root[data-theme="dark"] {
+  color-scheme: dark;
+}
+
+/* Motion tokens collapse to zero rather than being conditionally applied,
+   so every consumer honours reduced motion without opting in. */
+@media (prefers-reduced-motion: reduce) {
+  :root {
+    --motion-fast: 0ms;
+    --motion-medium: 0ms;
+  }
+}

package/src/aws-preflight.mjs

@@ -0,0 +1,60 @@
+import lock from './runtime/aws-python-lock.json' with {type:'json'};
+export function awsPreflightFiles(){return {
+ 'preflight-requirements.lock':lock.requirements,
+ 'preflight-aws.py':`"""Read-only checks against a saved Terraform plan; never applies or changes quotas."""
+import argparse
+import json
+from pathlib import Path
+import boto3
+from botocore.config import Config
+
+def concurrency_requirement(plan):
+    required=0
+    for item in plan.get("resource_changes",[]):
+        if item.get("type")!="aws_lambda_function":continue
+        change=item["change"]
+        if change.get("actions")==["delete"]:continue
+        after=(change.get("after") or {}).get("reserved_concurrent_executions")
+        before=(change.get("before") or {}).get("reserved_concurrent_executions")
+        if not isinstance(after,int) or after<1:raise ValueError("A positive explicit function concurrency bound is required")
+        # A replacement must reserve fresh capacity; do not rely on destruction ordering.
+        previous=before if isinstance(before,int) and before>0 and "delete" not in change.get("actions",[]) else 0
+        required+=max(0,after-previous)
+    return required
+
+def check_concurrency(plan,limits):
+    needed=concurrency_requirement(plan)
+    available=max(0,int(limits["UnreservedConcurrentExecutions"])-100)
+    return {"name":"lambda-reserved-concurrency-capacity","passed":needed<=available,"additionalRequired":needed,"availableForReservation":available,"accountLimit":limits["ConcurrentExecutions"],"action":None if needed<=available else "Request and wait for an appropriate regional concurrency quota increase; do not remove the per-function limit to bypass this check."}
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--plan-json",type=Path,required=True)
+    parser.add_argument("--receipt",type=Path,required=True)
+    args=parser.parse_args();plan=json.loads(args.plan_json.read_text())
+    values={key:entry.get("value") for key,entry in plan.get("variables",{}).items()}
+    account=values.get("aws_account_id");region=values.get("aws_region")
+    if not isinstance(account,str) or len(account)!=12 or not account.isdigit() or not isinstance(region,str):raise SystemExit("The plan must contain the reviewed AWS account and region")
+    session=boto3.Session(region_name=region)
+    config=Config(connect_timeout=5,read_timeout=20,retries={"total_max_attempts":2},ignore_configured_endpoint_urls=True)
+    identity=session.client("sts",config=config).get_caller_identity()
+    if identity["Account"]!=account:raise SystemExit("Account mismatch; target service checks were not run")
+    checks=[]
+    if any(r.get("type")=="aws_lambda_function" for r in plan.get("resource_changes",[])):
+        limits=session.client("lambda",config=config).get_account_settings()["AccountLimit"]
+        checks.append(check_concurrency(plan,limits))
+    models=sorted({value for key,value in values.items() if key.endswith("_model_id") and isinstance(value,str)})
+    if models:
+        bedrock=session.client("bedrock",config=config)
+        for model in models:
+            availability=bedrock.get_foundation_model_availability(modelId=model)
+            details=bedrock.get_foundation_model(modelIdentifier=model)["modelDetails"]
+            checks.append({"name":"bedrock-control-plane-availability","modelId":model,"passed":availability.get("authorizationStatus")=="AUTHORIZED" and availability.get("regionAvailability")=="AVAILABLE" and availability.get("entitlementAvailability")=="AVAILABLE" and "ON_DEMAND" in details.get("inferenceTypesSupported",[]),"runtimeInvocation":"not_tested"})
+    result={"kind":"read-only-account-preflight","status":"passed" if all(c["passed"] for c in checks) else "blocked","accountSuffix":account[-4:],"region":region,"checks":checks,"deployment":"not_run","limitations":"Does not establish apply permissions, model quality, runtime authorization, recovery, billing or production readiness."}
+    args.receipt.parent.mkdir(parents=True,exist_ok=True);args.receipt.write_text(json.dumps(result,indent=2)+"\\n")
+    print(json.dumps(result))
+    if result["status"]!="passed":raise SystemExit(1)
+if __name__=="__main__":main()
+`,
+ 'PREFLIGHT.md':'# Verify account prerequisites before applying\n\nAfter reviewing `terraform plan -out=reviewed.tfplan`, write `terraform show -json reviewed.tfplan > reviewed-plan.json`. Treat both files as sensitive. Create a local Python virtual environment and install `preflight-requirements.lock` using `pip install --require-hashes --only-binary=:all: -r preflight-requirements.lock`. With the standard AWS credential chain set to the reviewed account, run `python preflight-aws.py --plan-json reviewed-plan.json --receipt preflight-receipt.json`.\n\nThe script reads STS identity, regional Lambda reservation capacity and selected Bedrock model control-plane availability. It never creates resources, changes quotas or invokes a model. A quota shortfall must be resolved before apply; do not remove concurrency limits to bypass it. Bedrock catalog access is not proof of Converse runtime access or model quality.\n\nApply only the reviewed plan after all account, policy, cost, operational and application checks are satisfied. Rerun checks when the plan or account changes.\n',
+};}

package/src/aws-public-faq.mjs

@@ -0,0 +1,102 @@
+import {builder,v,ref} from './public-faq-builder.mjs';
+import {CLOUD_PROVIDER_LOCKS} from './cloud-provider-locks.mjs';
+import {faqLambdaBuild} from './faq-lambda-build.mjs';
+
+// A small synchronous public FAQ does not need App Runner eligibility, an ECR
+// repository or a continuously running load balancer/container. No service
+// lifecycle exception is delegated to the visitor or hidden behind a mock pass.
+export function awsPublicFaqTerraform(project,plan,environment='staging'){
+ const b=builder(project,plan,environment,'aws'),{input,add}=b;
+ const account=input('account_id','Reviewed destination AWS account; approved operator credential chain only.','123456789012','^[0-9]{12}$');
+ const region=input('region','Reviewed commercial AWS region with Lambda, HTTP API and the direct regional Bedrock model; no cross-region inference fallback.','ap-southeast-2','^[a-z]{2}-[a-z]+-[0-9]$');
+ const entries=plan.publicFaqPlan.entries;
+ if(entries.every(e=>e.row.region===entries[0].row.region)&&/^[a-z]{2}-[a-z]+-[0-9]$/.test(entries[0].row.region)){b.variable.region.default=entries[0].row.region;b.examples.region=entries[0].row.region;}
+ b.data.aws_caller_identity={destination:{}};
+ b.resource.terraform_data.review_gate.lifecycle.precondition.push({condition:'${data.aws_caller_identity.destination.account_id == var.account_id}',error_message:'Approved operator must target the reviewed AWS account.'});
+ for(const {row}of entries){
+  const n=row.address,name=input(n+'_name','Unique application and IAM role name.','reviewed-public-help','^[a-z][a-z0-9-]{3,28}[a-z0-9]$');
+  const model=input(n+'_model_id','Reviewed direct regional Converse foundation model ID; verify availability, quotas, context size, terms and retention-none compatibility.','anthropic.reviewed-model-v1:0','^[a-z0-9][a-z0-9.-]*:[0-9]+$');
+  const editor=input(n+'_editor_principal_arn','Existing authorized same-account company editor role; it alone may assume the separate catalog editor role.','arn:aws:iam::123456789012:role/reviewed-company-editors','^arn:aws:iam::[0-9]{12}:role/[A-Za-z0-9_+=,.@/-]{1,512}$');
+  b.resource.terraform_data.review_gate.lifecycle.precondition.push({condition:'${split(":", var.'+n+'_editor_principal_arn)[4] == var.account_id}',error_message:'Existing editor role must belong to the reviewed account.'});
+  add('aws_s3_bucket',n,{bucket:account+'-'+name+'-catalog',force_destroy:false,lifecycle:{prevent_destroy:true}});
+  const bucket=ref('aws_s3_bucket',n,'id'),bucketArn=ref('aws_s3_bucket',n,'arn'),objectArn=bucketArn+'/catalog.json';
+  add('aws_s3_bucket_public_access_block',n,{bucket,block_public_acls:true,block_public_policy:true,ignore_public_acls:true,restrict_public_buckets:true});
+  add('aws_s3_bucket_ownership_controls',n,{bucket,rule:{object_ownership:'BucketOwnerEnforced'}});
+  add('aws_s3_bucket_server_side_encryption_configuration',n,{bucket,rule:{apply_server_side_encryption_by_default:{sse_algorithm:'AES256'},bucket_key_enabled:false}});
+  add('aws_s3_bucket_versioning',n,{bucket,versioning_configuration:{status:'Enabled'}});
+  add('aws_s3_bucket_lifecycle_configuration',n,{bucket,rule:{id:'expire-old-catalog-versions',status:'Enabled',filter:{prefix:''},noncurrent_version_expiration:{noncurrent_days:7},abort_incomplete_multipart_upload:{days_after_initiation:1}},depends_on:['aws_s3_bucket_versioning.'+n]});
+  add('aws_s3_bucket_policy',n,{bucket,policy:JSON.stringify({Version:'2012-10-17',Statement:[{Sid:'RequireTLS',Effect:'Deny',Principal:'*',Action:'s3:*',Resource:[bucketArn,bucketArn+'/*'],Condition:{Bool:{'aws:SecureTransport':'false','aws:PrincipalIsAWSService':'false'}}}]}),depends_on:['aws_s3_bucket_public_access_block.'+n]});
+  add('aws_iam_role',n,{name:name+'-runtime',assume_role_policy:JSON.stringify({Version:'2012-10-17',Statement:[{Effect:'Allow',Principal:{Service:'lambda.amazonaws.com'},Action:'sts:AssumeRole'}]})});
+  add('aws_cloudwatch_log_group',n,{name:'/aws/lambda/'+name,retention_in_days:7});
+  add('aws_iam_role_policy',n,{role:ref('aws_iam_role',n,'id'),policy:JSON.stringify({Version:'2012-10-17',Statement:[{Effect:'Allow',Action:['s3:GetObject'],Resource:objectArn},{Effect:'Allow',Action:['bedrock:InvokeModel'],Resource:'arn:aws:bedrock:'+region+'::foundation-model/'+model},{Effect:'Allow',Action:['bedrock:GetAccountDataRetention','bedrock:GetModelInvocationLoggingConfiguration'],Resource:'*',Condition:{StringEquals:{'aws:RequestedRegion':region}}},{Effect:'Allow',Action:['logs:CreateLogStream','logs:PutLogEvents'],Resource:ref('aws_cloudwatch_log_group',n,'arn')+':*'}]})});
+  add('aws_iam_role',n+'_editor',{name:name+'-catalog-editor',assume_role_policy:JSON.stringify({Version:'2012-10-17',Statement:[{Effect:'Allow',Principal:{AWS:editor},Action:'sts:AssumeRole'}]})});
+  add('aws_iam_role_policy',n+'_editor',{role:ref('aws_iam_role',n+'_editor','id'),policy:JSON.stringify({Version:'2012-10-17',Statement:[{Effect:'Allow',Action:['s3:GetObject','s3:PutObject'],Resource:objectArn}]})});
+  add('aws_apigatewayv2_api',n,{name,protocol_type:'HTTP',disable_execute_api_endpoint:false});
+  const origin=ref('aws_apigatewayv2_api',n,'api_endpoint'),settings={REGION:region,ACCOUNT_ID:account,MODEL_ID:model,MAX_OUTPUT_TOKENS:'1024',CATALOG_BUCKET:bucket,PUBLIC_ORIGIN:origin};
+  add('aws_lambda_function',n,{function_name:name,role:ref('aws_iam_role',n,'arn'),runtime:'python3.13',handler:'lambda_faq.handler',architectures:['x86_64'],filename:'${path.module}/build/'+n+'.zip',source_code_hash:'${filebase64sha256("${path.module}/build/'+n+'.zip")}',timeout:29,memory_size:512,reserved_concurrent_executions:5,publish:true,environment:{variables:settings},logging_config:{log_format:'JSON',application_log_level:'WARN',system_log_level:'WARN'},depends_on:['aws_iam_role_policy.'+n,'aws_s3_bucket_policy.'+n,'aws_s3_bucket_server_side_encryption_configuration.'+n,'aws_s3_bucket_versioning.'+n,'aws_cloudwatch_log_group.'+n]});
+  add('aws_lambda_alias',n,{name:'live',function_name:ref('aws_lambda_function',n,'function_name'),function_version:ref('aws_lambda_function',n,'version')});
+  add('aws_apigatewayv2_integration',n,{api_id:ref('aws_apigatewayv2_api',n,'id'),integration_type:'AWS_PROXY',integration_uri:ref('aws_lambda_alias',n,'invoke_arn'),payload_format_version:'2.0',timeout_milliseconds:29000});
+  add('aws_apigatewayv2_route',n,{api_id:ref('aws_apigatewayv2_api',n,'id'),route_key:'$default',authorization_type:'NONE',target:'integrations/'+ref('aws_apigatewayv2_integration',n,'id')});
+  add('aws_apigatewayv2_stage',n,{api_id:ref('aws_apigatewayv2_api',n,'id'),name:'$default',auto_deploy:true,default_route_settings:{throttling_burst_limit:10,throttling_rate_limit:10},depends_on:['aws_apigatewayv2_route.'+n]});
+  add('aws_lambda_permission',n,{statement_id:'OnlyOwnedHttpApi',action:'lambda:InvokeFunction',function_name:ref('aws_lambda_function',n,'function_name'),qualifier:ref('aws_lambda_alias',n,'name'),principal:'apigateway.amazonaws.com',source_account:account,source_arn:ref('aws_apigatewayv2_api',n,'execution_arn')+'/*/*'});
+  b.output[n+'_url']={value:origin+'/'};b.output[n+'_catalog']={value:{bucket,region}};b.output[n+'_editor_role_arn']={value:ref('aws_iam_role',n+'_editor','arn')};b.source(row);
+  b.assertions.push(`run "${n}_public_boundary" {\n command = plan\n assert {\n condition = aws_s3_bucket_public_access_block.${n}.block_public_policy && aws_s3_bucket_public_access_block.${n}.restrict_public_buckets && !aws_s3_bucket.${n}.force_destroy\n error_message = "Only the app is public; catalog storage remains private and protected."\n }\n assert {\n condition = jsondecode(aws_iam_role_policy.${n}.policy).Statement[0].Action == ["s3:GetObject"] && toset(jsondecode(aws_iam_role_policy.${n}_editor.policy).Statement[0].Action) == toset(["s3:GetObject", "s3:PutObject"])\n error_message = "Workload read and separate conditional editor write authority must stay distinct."\n }\n assert {\n condition = aws_lambda_function.${n}.reserved_concurrent_executions == 5 && aws_lambda_function.${n}.timeout == 29 && aws_apigatewayv2_integration.${n}.payload_format_version == "2.0" && aws_apigatewayv2_route.${n}.authorization_type == "NONE"\n error_message = "This explicit public-only synchronous module uses bounded Lambda concurrency and the implemented HTTP API v2 event contract."\n }\n assert {\n condition = aws_lambda_permission.${n}.source_account == var.account_id && aws_lambda_permission.${n}.qualifier == "live"\n error_message = "Only the owned account/API may invoke the published live alias."\n }\n}`);
+ }
+ Object.assign(b.files,faqLambdaBuild(entries.map(e=>e.row.address)));
+ const config={terraform:{required_version:'>= 1.17.1, < 2.0.0',required_providers:{aws:{source:'hashicorp/aws',version:'6.72.0'}}},provider:{aws:{region,allowed_account_ids:[account],default_tags:{tags:{ManagedBy:'AtMem AI Architect',Environment:environment}}}}};
+ const mocks=`mock_provider "aws" {\n override_during = plan\n mock_data "aws_caller_identity" { defaults = { account_id = "${b.examples.account_id}" } }\n mock_resource "aws_iam_role" { defaults = { arn = "arn:aws:iam::${b.examples.account_id}:role/mock-role" } }\n mock_resource "aws_s3_bucket" { defaults = { id = "mock-catalog", arn = "arn:aws:s3:::mock-catalog" } }\n mock_resource "aws_cloudwatch_log_group" { defaults = { arn = "arn:aws:logs:${b.examples.region}:${b.examples.account_id}:log-group:/aws/lambda/mock" } }\n mock_resource "aws_lambda_function" { defaults = { arn = "arn:aws:lambda:${b.examples.region}:${b.examples.account_id}:function:mock", version = "1" } }\n mock_resource "aws_lambda_alias" { defaults = { arn = "arn:aws:lambda:${b.examples.region}:${b.examples.account_id}:function:mock:live", invoke_arn = "arn:aws:apigateway:${b.examples.region}:lambda:path/2015-03-31/functions/arn:aws:lambda:${b.examples.region}:${b.examples.account_id}:function:mock:live/invocations" } }\n mock_resource "aws_apigatewayv2_api" { defaults = { id = "mockapi1234", api_endpoint = "https://mockapi1234.execute-api.${b.examples.region}.amazonaws.com", execution_arn = "arn:aws:execute-api:${b.examples.region}:${b.examples.account_id}:mockapi1234" } }\n}\n`;
+ b.assertions.push(`run "wrong_account_blocked" {\n command = plan\n variables { account_id = "999999999999" }\n expect_failures = [terraform_data.review_gate]\n}`);
+ return b.finish(config,CLOUD_PROVIDER_LOCKS.aws,mocks,AWS_PUBLIC_FAQ_GUIDE);
+}
+
+export const AWS_PUBLIC_FAQ_GUIDE=`# AWS public-only FAQ: Lambda and HTTP API
+
+This small synchronous public assistant uses generated Python 3.13 source with the
+hash-pinned Mangum ASGI adapter, a published Lambda version/live alias and HTTP API
+v2. It has no App Runner eligibility requirement, ECR dependency, always-on task or
+load balancer. AWS closed App Runner to new customers; do not silently substitute
+it or ask a basic visitor to resolve that restriction.
+
+Run python3 build-runtime.py first. It builds the exact Linux x86_64 wheel closure
+and deterministic ZIP from applications/* source, metadata and web assets. Retain
+build/artifact-hashes.json. Run emitted faq_acceptance.py and the real Mangum HTTP
+API event tests in a matching isolated Python environment; qualify the exact ZIP
+inside the reviewed AWS Python 3.13 Linux runtime. Schema/mock/local tests never
+establish real Lambda, IAM or model behavior. There is no Terraform execution hook.
+
+The private S3 catalog has public-access blocks, TLS-only policy, AES256 encryption,
+owner-enforced ownership, versioning and seven-day noncurrent expiry. Runtime has
+GetObject only on catalog.json, direct selected regional Bedrock InvokeModel and
+read-only regional retention/logging checks. A separate role assumed by the
+existing reviewed company editor has Get/Put only on catalog.json. Article removal
+conditionally rewrites the manifest; no object DELETE or bucket administration
+is granted. Review inherited IAM and recovery/version-erasure requirements.
+
+Seed genuinely public articles via the separate operator CLI before traffic. No
+private source, arbitrary URL fetch, editing HTTP endpoint, end-user sign-in,
+question/answer persistence or content-bearing application log is implemented.
+Only the owned account/API receives permission to invoke the published live alias.
+Same-origin checks are browser hygiene, not visitor authentication. Runtime logs
+are WARN-only with seven-day retention; review all platform/audit logging separately.
+
+Converse requests JSON with independently checked schema, source IDs and exact
+quotes. It does not claim constrained Bedrock grammar, whose first compilation
+can exceed this 29-second boundary. The app fails closed on invalid output, stale
+or inaccessible source, unknown retention or enabled model text logging. It never
+changes account-wide model policy. Verify actual model availability, retention-none
+eligibility, region/context/quota/terms and real answer/citation/abstention/latency.
+Long-running work requires the separate durable workflow contract, not a longer
+synchronous timeout or a falsely successful response.
+
+Reserved Lambda concurrency is five, with bounded HTTP API throttles. These are
+capacity controls, not an invoice cap, anonymous abuse protection or SLA. Verify
+destination concurrency quota, cold starts, current prices, budgets and abuse policy.
+No prices are invented. Protect state and variable files. Review account/region,
+native Terraform schemas/tests and a separately authorized real plan before apply.
+No export proves deployment; production state/backup/operations remain gated.
+
+References:
+- https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html
+- https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+- https://mangum.fastapiexpert.com/adapter/
+`;

package/src/aws-validation-scenarios.mjs

@@ -0,0 +1,10 @@
+// Synthetic acceptance scenarios, not deployment configurations or invented customer requirements.
+export const AWS_SCENARIOS = [
+ {id:'01-private-storage',name:'Private document storage',prompt:'I need a private place on AWS to store a small set of synthetic text documents for a deployment test. Keep public access blocked and enable encryption and versioning. This first scenario only needs storage; no AI, database or web application.',expected:['s3'],checks:['Authorized upload/download preserves bytes','Unauthenticated access is denied','Versioning/encryption/public-access settings verified','Approved cleanup leaves no scenario resources']},
+ {id:'02-document-compute',name:'Document statistics',prompt:'Build a small AWS application that accepts a synthetic text document through an authenticated invocation and returns its word count and character count. Use serverless compute, a least-privilege execution identity and operational logs. No model or public anonymous endpoint is needed.',expected:['lambda'],checks:['Known input returns exact counts','Malformed and oversized payloads are rejected','Unauthorized invocation fails','Updated application version is observable']},
+ {id:'03-async-documents',name:'Asynchronous document processing',prompt:'On AWS, when a synthetic text file arrives in private object storage, queue it and process it with a serverless worker. Save its word count as a result. Duplicate deliveries must be safe, failures must retry, and poison messages must go to a dead-letter queue.',expected:['s3','sqs','lambda'],checks:['Upload produces a stored result','Duplicate events do not corrupt results','Poison event reaches dead-letter queue','Recovery/replay succeeds']},
+ {id:'04-model-summary',name:'Model-backed summarization',prompt:'Build an authenticated AWS service that summarizes synthetic text using Amazon Bedrock. Include runtime, model invocation permissions and operational logging. Model selection and region availability must be verified before deployment. Bound request size, output tokens, retries and invocation concurrency.',expected:['bedrock'],checks:['Approved model returns a summary of the supplied text','Token/request limits enforced','Denied model access and throttling handled','Logs exclude sensitive input']},
+ {id:'05-cited-rag',name:'Cited answers from documents',prompt:'Build an AWS assistant that answers questions from a small synthetic document collection with source citations. Include ingestion, retrieval/indexing, model generation and an application interface. It must say when evidence is insufficient, and reflect document updates and deletions. For this first end-to-end qualification, use the approved bounded keyword-retrieval mode for at most 100 small documents; managed vector retrieval will be qualified separately.',expected:['bedrock'],checks:['Known questions retrieve expected evidence','Citations refer to supplied documents','Unsupported question abstains','Updates/deletions change retrieval results']},
+ {id:'06-permission-rag',name:'Permission-aware retrieval',prompt:'Build an authenticated AWS knowledge assistant for synthetic users Alice and Bob with different document permissions. Enforce access and employee region before evidence reaches the model. Restricted titles, snippets and citations must not leak. Test revoked permissions and unknown identity; these must fail safely. Use the approved bounded keyword-retrieval mode for this first test, with IAM-authenticated API access and authoritative employee-region mappings.',expected:['bedrock'],checks:['Alice cannot retrieve Bob-only evidence','No restricted title/snippet/citation leakage','Revocation propagates within agreed bound','Unknown identity/region is denied']},
+ {id:'07-enterprise-connectors',name:'External sources and channels',prompt:'Design an AWS knowledge assistant that reads approved documents from existing SharePoint and Confluence systems and provides cited answers through a web application, with Teams as a later channel. Preserve source permissions, updates and deletes. For this stage use the approved local normalized source-contract test servers and bounded keyword retrieval. Keep the requested web application as required scope; an HTTP API alone does not complete that channel. Treat those existing systems as external dependencies; include recovery and audit behavior without claiming native vendor API or real tenant compatibility.',expected:['bedrock'],checks:['Approved source connection synchronizes documents','Source deletes and ACL changes propagate','Source outage retries and recovers','Authenticated channel preserves identity and citations']},
+];

package/src/aws-validation.mjs

@@ -0,0 +1,48 @@
+// Mechanical architecture checks. These do not establish deployed behavior or model quality.
+export function assessAwsArchitecture(project,scenario){
+ const nodes=project.nodes.filter(n=>n.data.kind!=='note');
+ const text=n=>String(n.data.service||n.data.label||'').toLowerCase();
+ const has=re=>nodes.some(n=>n.data.provider==='aws'&&re.test(text(n)));
+ const ids=new Set(nodes.map(n=>n.id));
+ const edges=project.edges.filter(e=>ids.has(e.source)&&ids.has(e.target));
+ const visited=new Set(nodes.length?[nodes[0].id]:[]);
+ for(let changed=true;changed;){changed=false;for(const e of edges)if(visited.has(e.source)!==visited.has(e.target)){visited.add(e.source);visited.add(e.target);changed=true;}}
+ const checks=[{id:'nonempty',passed:nodes.length>0},{id:'unique-component-ids',passed:ids.size===nodes.length},{id:'valid-edge-endpoints',passed:project.edges.every(e=>project.nodes.some(n=>n.id===e.source)&&project.nodes.some(n=>n.id===e.target))},{id:'connected-graph',passed:nodes.length>0&&visited.size===nodes.length},{id:'aws-proposed-components',passed:nodes.filter(n=>n.data.origin!=='existing'&&n.data.role!=='human').every(n=>n.data.provider==='aws')},...scenario.expected.map(name=>({id:`service-${name}`,passed:has(new RegExp(name,'i'))}))];
+ if(scenario.id==='01-private-storage')checks.push({id:'storage-only-scope',passed:!has(/bedrock|lambda|opensearch|dynamodb|ecs|app\s*runner/)},{id:'operator-access-contract',passed:nodes.some(n=>n.data.binding==='aws-iam-principal'&&n.data.provider==='tools'&&n.data.origin==='existing'&&edges.some(e=>e.source===n.id&&e.access==='s3-read-write'&&nodes.some(t=>t.id===e.target&&t.data.provider==='aws'&&/\bs3\b/.test(text(t)))))});
+ if(['03-async-documents','04-model-summary','05-cited-rag','06-permission-rag','07-enterprise-connectors'].includes(scenario.id))checks.push({id:'connected-components',passed:project.edges.length>0&&nodes.every(n=>project.edges.some(e=>e.source===n.id||e.target===n.id))});
+ if(scenario.id==='03-async-documents'){
+  const queues=nodes.filter(n=>/sqs/.test(text(n)));
+  checks.push({id:'queue-connected-to-worker',passed:queues.some(q=>project.edges.some(e=>e.source===q.id&&nodes.some(n=>n.id===e.target&&/lambda/.test(text(n)))))});
+ }
+ if(['05-cited-rag','06-permission-rag','07-enterprise-connectors'].includes(scenario.id))checks.push({id:'retrieval-component',passed:has(/opensearch|knowledge\s*base|retriev|search|vector/)||nodes.some(n=>n.data.role==='index'||n.data.implementation==='bounded-rag-catalog')});
+ if(scenario.id==='06-permission-rag')checks.push({id:'identity-or-access-component',passed:has(/identity|cognito|single.sign|authoriz|permission|access/)||nodes.some(n=>n.data.provider==='aws'&&n.data.implementation==='iam-rag-api')});
+ if(scenario.id==='07-enterprise-connectors')checks.push({id:'web-application-component',passed:nodes.some(n=>n.data.implementation==='rag-web-app')});
+ if(scenario.id==='07-enterprise-connectors')for(const source of ['sharepoint','confluence'])checks.push({id:`existing-${source}`,passed:nodes.some(n=>text(n).includes(source)&&n.data.origin==='existing')});
+ return {passed:checks.every(c=>c.passed),checks,limitations:'Structural checks only. Application correctness, security, service availability and deployment require independent evidence.'};
+}
+
+// A conservative decision about the next validation stage, never a probability of success.
+// Only the local test runner supplies evidence; model prose is not execution evidence.
+export function assessAwsDeploymentCandidate(project, scenario, terraform, evidence = {}) {
+ const architecture=assessAwsArchitecture(project,scenario);
+ const blockers=architecture.checks.filter(c=>!c.passed).map(c=>({id:`architecture-${c.id}`,owner:'architecture',message:`Architecture check failed: ${c.id}`}));
+ const add=(id,owner,message)=>blockers.push({id,owner,message});
+ const resources=terraform?.resource||{};
+ const count=Object.entries(resources).filter(([type])=>type.startsWith('aws_')).reduce((sum,[,items])=>sum+Object.keys(items||{}).length,0);
+ if(!count)add('no-cloud-resources','generator','No AWS resources are emitted; a valid review gate is not a deployment.');
+ const expected={s3:'aws_s3_bucket',lambda:'aws_lambda_function',sqs:'aws_sqs_queue'};
+ for(const family of scenario.expected)if(expected[family]&&!Object.keys(resources[expected[family]]||{}).length)add(`missing-${family}`,'generator',`Required ${expected[family]} is absent from the export.`);
+ const unfinished=terraform?.locals?.unfinished_work;
+ if(!Array.isArray(unfinished))add('missing-coverage-evidence','generator','Export does not declare unresolved implementation coverage.');
+ else for(const gap of unfinished)add(`unfinished-${gap}`,'implementation',`Unresolved generated work: ${gap}`);
+ if(scenario.id!=='01-private-storage'&&evidence.applicationTests!=='passed')add('application-not-qualified','application','No executable application acceptance evidence for this artifact.');
+ if(evidence.providerSchema!=='passed')add('provider-schema-unverified','validation','Run provider-schema validation against this exact export.');
+ if(evidence.requirementsReview!=='passed')add('requirements-review-unverified','review','Review requirements against emitted configuration, including identity, limits, region, costs and cleanup.');
+ return {status:blockers.length?'blocked':'ready_for_account_plan',awsResourceCount:count,blockers,
+  cloudPlan:evidence.cloudPlan||'not_run',deployment:evidence.deployment||'not_run',
+  limitations:'No numerical success probability is justified. Schema validity does not prove complete coverage, runtime behavior or deployability. A ready-for-plan result is not permission to deploy.'};
+}
+
+export function awsRefinementPrompt(assessment) {
+ return `Review this same architecture and its generated Terraform. Keep the original scenario scope and preserve valid component IDs and existing systems. Validation findings: ${JSON.stringify(assessment.blockers)}. Correct architecture defects through a proposal where supported. For missing native resources, application code or integrations, explain the product implementation gap and next concrete engineering action; do not claim a diagram edit implemented it. Do not remove required components, weaken acceptance checks or clear unfinished-work gates to obtain a pass. Do not claim tests ran or request deployment. Identify what remains unverified.`;
+}

package/src/azure-plan-mocks.mjs

@@ -0,0 +1,25 @@
+// Only computed upstream identities/IDs are supplied. Never override the web-app
+// configuration under test: its cross-field and ID validation must actually run.
+export function azurePlanMocks({subscription,tenant,resourceGroup,addresses,entra=false}){
+ const rg='/subscriptions/'+subscription+'/resourceGroups/'+resourceGroup;
+ const guid=n=>'00000000-0000-4000-8000-'+String(n).padStart(12,'0');
+ let text=`mock_provider "azurerm" {\n override_during = plan\n mock_data "azurerm_client_config" { defaults = { subscription_id = "${subscription}", tenant_id = "${tenant}" } }\n}\n`;
+ if(entra)text+='mock_provider "azuread" { override_during = plan }\n';
+ const override=(target,values)=>{text+='override_resource {\n override_during = plan\n target = '+target+'\n values = '+JSON.stringify(values)+'\n}\n';};
+ addresses.forEach((n,i)=>{
+  const seed=100+i*10;
+  override('azurerm_user_assigned_identity.'+n,{id:rg+'/providers/Microsoft.ManagedIdentity/userAssignedIdentities/mock-runtime-'+i,client_id:guid(seed),principal_id:guid(seed+1)});
+  override('azurerm_service_plan.'+n,{id:rg+'/providers/Microsoft.Web/serverFarms/mock-plan-'+i});
+  override('azurerm_cognitive_account.'+n,{id:rg+'/providers/Microsoft.CognitiveServices/accounts/mock-ai-'+i,endpoint:'https://mock-ai-'+i+'.openai.azure.com/'});
+  if(entra){
+   override('azuread_application_registration.'+n,{id:'/applications/'+guid(seed+2),client_id:guid(seed+3)});
+   override('azuread_application_registration.'+n+'_spa',{id:'/applications/'+guid(seed+4),client_id:guid(seed+5)});
+   override('azuread_service_principal.'+n,{object_id:guid(seed+6)});
+  }else{
+   const storage=rg+'/providers/Microsoft.Storage/storageAccounts/mockstorage'+i;
+   override('azurerm_storage_account.'+n,{id:storage});
+   override('azurerm_storage_container.'+n,{id:storage+'/blobServices/default/containers/public-catalog'});
+  }
+ });
+ return text;
+}

package/src/azure-structured.mjs

@@ -0,0 +1,133 @@
+import {azurePlanMocks} from './azure-plan-mocks.mjs';
+import {pythonContainer} from './python-container.mjs';
+import sources from './runtime/azure-sources.json' with {type:'json'};
+import lock from './runtime/azure-python-lock.json' with {type:'json'};
+import testLock from './runtime/azure-test-lock.json' with {type:'json'};
+import base from './runtime/python-container-lock.json' with {type:'json'};
+import {STRUCTURED_WEB_HTML,STRUCTURED_WEB_CSS,STRUCTURED_WEB_JS} from './structured-web.mjs';
+import {structuredContract} from './structured-contract.mjs';
+import {existingDeployment} from './deployment-ownership.mjs';
+import {existingReferenceFiles} from './existing-references.mjs';
+import {CLOUD_PROVIDER_LOCKS} from './cloud-provider-locks.mjs';
+
+export function azureStructuredPlan(project,rows){
+ const entries=[];
+ for(const node of project.nodes){
+  if(node.data.provider!=='azure'||node.data.implementation!=='azure-structured-app'||node.data.service!=='Azure App Service'||existingDeployment(node))continue;
+  const contract=structuredContract(node.data.config?.outputContract);
+  if(!contract)continue;
+  const maxInput=node.data.config?.maxInputBytes??20000,maxTokens=node.data.config?.maxOutputTokens??1024;
+  if(!Number.isInteger(maxInput)||maxInput<1||maxInput>20000||!Number.isInteger(maxTokens)||maxTokens<32||maxTokens>4096)throw Error('Azure structured application limits must be 1–20000 input bytes and 32–4096 output tokens.');
+  entries.push({row:rows.find(r=>r.id===node.id),contract,maxInput,maxTokens});
+ }
+ const ids=new Set(entries.map(e=>e.row.id));
+ const browsers=new Set(project.nodes.filter(n=>existingDeployment(n)&&n.data.provider==='tools'&&n.data.binding==='web-browser').map(n=>n.id));
+ const edges=project.edges.filter(e=>e.integration==='browser-https'&&browsers.has(e.source)&&ids.has(e.target));
+ return {entries,componentIds:[...ids],edgeIds:edges.map(e=>e.id)};
+}
+
+const v=n=>'${var.'+n+'}',ref=(type,n,key)=>'${'+type+'.'+n+'.'+key+'}';
+export function azureStructuredTerraform(project,plan,environment='staging'){
+ const entries=plan.azureStructuredPlan.entries;
+ if(!entries.length)throw Error('No Azure structured application composition.');
+ const variable={review_approved:{type:'bool',default:false,description:'Approve only after reviewing the emitted code, destination, identity, policy, costs and plan.'}};
+ const examples={review_approved:false},resource={},output={},files={},tests=[];
+ const input=(name,description,example,pattern)=>{
+  variable[name]={type:'string',nullable:false,description,validation:{condition:pattern?'${can(regex('+JSON.stringify(pattern)+', var.'+name+'))}':'${length(trimspace(var.'+name+')) > 0}',error_message:'Supply the reviewed '+name+' value.'}};
+  examples[name]=example;return v(name);
+ };
+ const uuid='^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$';
+ const subscription=input('subscription_id','Expected destination Azure subscription. Terraform uses the operator credential chain.','11111111-1111-1111-1111-111111111111',uuid);
+ const tenant=input('tenant_id','Expected company Microsoft Entra tenant. Both providers are bound to this tenant.','22222222-2222-2222-2222-222222222222',uuid);
+ const rg=input('resource_group_name','Existing reviewed destination resource group. This module does not import or recreate it.','reviewed-application-rg','^[A-Za-z0-9_.()-]{1,90}$');
+ const registry=input('registry_name','Existing Azure Container Registry name, with standard RBAC registry permission mode. No registry is recreated.','reviewedregistry','^[a-z0-9]{5,50}$');
+ const registryRg=input('registry_resource_group_name','Existing registry resource group in the selected subscription.','reviewed-registry-rg','^[A-Za-z0-9_.()-]{1,90}$');
+ const registryId='/subscriptions/'+subscription+'/resourceGroups/'+registryRg+'/providers/Microsoft.ContainerRegistry/registries/'+registry;
+ const registryUrl='https://'+registry+'.azurecr.io';
+ const add=(type,name,body)=>((resource[type]||={})[name]={...body,depends_on:['terraform_data.review_gate',...(body.depends_on||[])]});
+ const gaps=[...plan.gapDetails.map(g=>g.id),...(environment==='production'?['production-state-backup-and-operating-review-required']:[])];
+ resource.terraform_data={review_gate:{input:{design_revision:project.revision,environment},lifecycle:{precondition:[{condition:'${var.review_approved && length(local.unfinished_work) == 0}',error_message:'Resolve required implementation work and review the exact destination and emitted package.'}]}}};
+ for(const {row,contract,maxInput,maxTokens} of entries){
+  const n=row.address;
+  const name=input(n+'_name','Unique application name. This composition includes API, browser, Entra registrations and a regional Azure OpenAI deployment.','reviewed-app','^[a-z][a-z0-9-]{4,28}[a-z0-9]$');
+  const location=input(n+'_location','Reviewed application/model region. Regional Standard model availability, version and quota must be verified.','australiaeast','^[a-z][a-z0-9]{2,39}$');
+  if(/^[a-z][a-z0-9]{2,39}$/.test(row.region)){variable[n+'_location'].default=row.region;examples[n+'_location']=row.region;}
+  const repository=input(n+'_repository','Existing registry repository to which the generated, tested application image will be pushed.','architect/app','^[a-z0-9]+(?:[._/-][a-z0-9]+)*$');
+  const digest=input(n+'_image_digest','SHA-256 digest from building this emitted source, not a placeholder image. Use the documented two-phase build/push then Terraform plan.','sha256:'+'0'.repeat(64),'^sha256:[0-9a-f]{64}$');
+  const modelName=input(n+'_model_name','Reviewed Azure OpenAI chat model; verify regional Standard availability and API compatibility. No model or price is invented.','REVIEW_MODEL');
+  const modelVersion=input(n+'_model_version','Explicit supported model version. Review lifecycle and quota in the destination before planning.','REVIEW_VERSION');
+  const group=input(n+'_access_group_object_id','Existing Entra security group allowed to use this API. Group assignment requires Entra P1/P2; no users or groups are created.','33333333-3333-3333-3333-333333333333',uuid);
+  const tags={ManagedBy:'AtMem AI Architect',Environment:environment,Component:n};
+  add('azurerm_user_assigned_identity',n,{name:name+'-runtime',location,resource_group_name:rg,tags});
+  add('azurerm_service_plan',n,{name:name+'-plan',location,resource_group_name:rg,os_type:'Linux',sku_name:'B1',worker_count:1,tags});
+  add('azurerm_cognitive_account',n,{name:name+'-ai',location,resource_group_name:rg,kind:'OpenAI',sku_name:'S0',custom_subdomain_name:name+'-ai',local_auth_enabled:false,public_network_access_enabled:true,tags,lifecycle:{prevent_destroy:true}});
+  add('azurerm_cognitive_deployment',n,{name:'structured-operation',cognitive_account_id:ref('azurerm_cognitive_account',n,'id'),version_upgrade_option:'NoAutoUpgrade',model:{format:'OpenAI',name:modelName,version:modelVersion},sku:{name:'Standard',capacity:1}});
+  const principal=ref('azurerm_user_assigned_identity',n,'principal_id');
+  add('azurerm_role_assignment',n,{scope:ref('azurerm_cognitive_account',n,'id'),role_definition_name:'Cognitive Services OpenAI User',principal_id:principal});
+  add('azurerm_role_assignment',n+'_policy',{scope:ref('azurerm_cognitive_account',n,'id'),role_definition_name:'Reader',principal_id:principal});
+  add('azurerm_role_assignment',n+'_pull',{scope:registryId,role_definition_name:'AcrPull',principal_id:principal});
+  const registration={display_name:name,sign_in_audience:'AzureADMyOrg',requested_access_token_version:2,implicit_access_token_issuance_enabled:false,implicit_id_token_issuance_enabled:false};
+  add('azuread_application_registration',n,registration);
+  add('azuread_application_registration',n+'_spa',{...registration,display_name:name+'-browser'});
+  const apiId=ref('azuread_application_registration',n,'id'),apiClient=ref('azuread_application_registration',n,'client_id'),spaId=ref('azuread_application_registration',n+'_spa','id'),spaClient=ref('azuread_application_registration',n+'_spa','client_id');
+  const role='${uuidv5("dns", format("%s:%s:workspace-user", var.tenant_id, var.'+n+'_name))}';
+  const scope='${uuidv5("dns", format("%s:%s:access-as-user", var.tenant_id, var.'+n+'_name))}';
+  add('azuread_application_identifier_uri',n,{application_id:apiId,identifier_uri:'api://'+apiClient});
+  add('azuread_application_permission_scope',n,{application_id:apiId,scope_id:scope,value:'access_as_user',type:'Admin',admin_consent_display_name:'Use the structured AI workspace',admin_consent_description:'Submit input for a bounded AI operation as the signed-in user.'});
+  add('azuread_application_app_role',n,{application_id:apiId,role_id:role,allowed_member_types:['User'],display_name:'Workspace user',description:'Use the structured AI operation.',value:'WorkspaceUser'});
+  add('azuread_service_principal',n,{client_id:apiClient,app_role_assignment_required:true,depends_on:['azuread_application_app_role.'+n]});
+  add('azuread_service_principal',n+'_spa',{client_id:spaClient,app_role_assignment_required:false});
+  add('azuread_app_role_assignment',n,{app_role_id:role,principal_object_id:group,resource_object_id:ref('azuread_service_principal',n,'object_id')});
+  add('azuread_application_api_access',n,{application_id:spaId,api_client_id:apiClient,scope_ids:[scope],depends_on:['azuread_application_permission_scope.'+n]});
+  add('azuread_application_pre_authorized',n,{application_id:apiId,authorized_client_id:spaClient,permission_ids:[scope],depends_on:['azuread_application_permission_scope.'+n]});
+  add('azurerm_linux_web_app',n,{name,location,resource_group_name:rg,service_plan_id:ref('azurerm_service_plan',n,'id'),https_only:true,ftp_publish_basic_authentication_enabled:false,webdeploy_publish_basic_authentication_enabled:false,identity:{type:'UserAssigned',identity_ids:[ref('azurerm_user_assigned_identity',n,'id')]},site_config:{always_on:true,minimum_tls_version:'1.2',scm_minimum_tls_version:'1.2',ftps_state:'Disabled',http2_enabled:true,remote_debugging_enabled:false,health_check_path:'/healthz',health_check_eviction_time_in_min:2,container_registry_use_managed_identity:true,container_registry_managed_identity_client_id:ref('azurerm_user_assigned_identity',n,'client_id'),application_stack:{docker_registry_url:registryUrl,docker_image_name:repository+'@'+digest}},app_settings:{WEBSITES_PORT:'8080',TENANT_ID:tenant,API_CLIENT_ID:apiClient,SPA_CLIENT_ID:spaClient,MANAGED_IDENTITY_CLIENT_ID:ref('azurerm_user_assigned_identity',n,'client_id'),MODEL_RESOURCE_ID:ref('azurerm_cognitive_account',n,'id'),MODEL_ENDPOINT:ref('azurerm_cognitive_account',n,'endpoint'),MODEL_DEPLOYMENT:ref('azurerm_cognitive_deployment',n,'name'),MAX_INPUT_BYTES:String(maxInput),MAX_OUTPUT_TOKENS:String(maxTokens),OUTPUT_CONTRACT_BASE64:btoa(unescape(encodeURIComponent(JSON.stringify(contract))))},tags,depends_on:['azurerm_role_assignment.'+n,'azurerm_role_assignment.'+n+'_policy','azurerm_role_assignment.'+n+'_pull','azuread_application_pre_authorized.'+n,'azuread_app_role_assignment.'+n]});
+  add('azuread_application_redirect_uris',n,{application_id:spaId,type:'SPA',redirect_uris:['https://'+ref('azurerm_linux_web_app',n,'default_hostname')+'/']});
+  output[n+'_url']={value:'https://'+ref('azurerm_linux_web_app',n,'default_hostname')+'/'};
+  output[n+'_model_resource_id']={value:ref('azurerm_cognitive_account',n,'id')};
+  const folder='applications/'+n+'/';
+  for(const [path,body] of Object.entries(sources))files[folder+path]=body;
+  files[folder+'web/index.html']=STRUCTURED_WEB_HTML;
+  files[folder+'web/app.css']=STRUCTURED_WEB_CSS;
+  files[folder+'web/app.js']=STRUCTURED_WEB_JS;
+  files[folder+'output-contract.json']=JSON.stringify(contract,null,2);
+  files[folder+'requirements.lock']=lock.requirements;
+  files[folder+'test-requirements.lock']=testLock.requirements;
+  files[folder+'test-dependency-sources.json']=JSON.stringify(testLock.sources,null,2);
+  files[folder+'dependency-sources.json']=JSON.stringify(lock.sources,null,2);
+  files[folder+'container-base.json']=JSON.stringify(base,null,2);
+  files[folder+'Dockerfile']=pythonContainer('azure_structured',['azure_structured.py','structured_output.py','structured_http.py']);
+  files[folder+'.dockerignore']='*\n!requirements.lock\n!output-contract.json\n!azure_structured.py\n!structured_output.py\n!structured_http.py\n!web/\n!web/*\n';
+  files[folder+'BUILD.md']=`# Generated Azure application\n\nThis source implements the browser, delegated Entra API authorization and bounded model operation. It is not a supplied-image placeholder. From this directory, create an isolated environment with python3.13 -m venv .venv, run .venv/bin/python -m pip install --only-binary=:all: --require-hashes -r test-requirements.lock, then .venv/bin/python azure_acceptance.py -v. Test dependencies have a separate hash-locked file and source receipts. Tests use cryptographic keys and scripted network boundaries; they do not access Azure.\n\nBuild on a clean Docker host: docker build --platform linux/amd64 --pull -t REVIEWED_REGISTRY.azurecr.io/REVIEWED_REPOSITORY:REVIEWED_BUILD .\n\nInspect and scan the image, run container startup and acceptance checks, then, with authorization, authenticate to the existing ACR and push it. Record the registry digest and supply it as ${n}_image_digest. The Terraform configuration uses managed-identity pull and never builds/pushes images or executes a provisioner. Building and publishing an image is separate from running Terraform. The base image and all Python wheels are hash pinned; record exact source/image hashes. Update deliberately and rerun tests/scans.\n\nThe test-requirements.lock file adds pinned httpx/HTTP transport tooling for FastAPI TestClient; those development tools are not packaged into the image. Test fixture config lives in azure_acceptance.py; never use fixture values as deployment credentials or production configuration.\n`;
+  tests.push(`run "${n}_security" {\n command = plan\n assert {\n condition = azurerm_linux_web_app.${n}.https_only && !azurerm_linux_web_app.${n}.ftp_publish_basic_authentication_enabled && !azurerm_linux_web_app.${n}.webdeploy_publish_basic_authentication_enabled && !azurerm_cognitive_account.${n}.local_auth_enabled\n error_message = "TLS and managed identity are required; basic publishing and model keys are disabled."\n }\n assert {\n condition = azurerm_cognitive_deployment.${n}.sku[0].name == "Standard" && azurerm_cognitive_deployment.${n}.version_upgrade_option == "NoAutoUpgrade"\n error_message = "Do not silently select a global deployment or model upgrade."\n }\n assert {\n condition = azuread_service_principal.${n}.app_role_assignment_required && azuread_application_registration.${n}.requested_access_token_version == 2\n error_message = "Tenant-specific v2 access and explicit group assignment are required."\n }\n}\nrun "${n}_reject_mutable_image" {\n command = plan\n variables { ${n}_image_digest = "latest" }\n expect_failures = [var.${n}_image_digest]\n}`);
+ }
+ const config={terraform:{required_version:'>= 1.7.0, < 2.0.0',required_providers:{azurerm:{source:'hashicorp/azurerm',version:'4.81.0'},azuread:{source:'hashicorp/azuread',version:'3.10.0'}}},provider:{azurerm:{features:{},subscription_id:subscription,tenant_id:tenant,resource_provider_registrations:'none'},azuread:{tenant_id:tenant}},variable,locals:{unfinished_work:gaps},resource,output};
+ const values=Object.entries({...examples,review_approved:true}).map(([key,val])=>key+' = '+JSON.stringify(val)).join('\n');
+ return {...files,...existingReferenceFiles(project),'.terraform.lock.hcl':CLOUD_PROVIDER_LOCKS.azure+'\n'+CLOUD_PROVIDER_LOCKS.azuread,'.gitignore':'.terraform/\n*.tfstate*\n*.tfplan\n*.tfvars\n*.tfvars.json\n!deployment.tfvars.json.example\n.venv/\n__pycache__/\n','main.tf.json':JSON.stringify(config,null,2),'resource-schedule.json':JSON.stringify(plan,null,2),'deployment.tfvars.json.example':JSON.stringify(examples,null,2),'tests/azure-structured.tftest.hcl':azurePlanMocks({subscription:examples.subscription_id,tenant:examples.tenant_id,resourceGroup:examples.resource_group_name,addresses:entries.map(e=>e.row.address),entra:true})+`variables {\n${values}\n}\n${tests.join('\n')}\nrun "unapproved_blocked" {\n command = plan\n variables { review_approved = false }\n expect_failures = [terraform_data.review_gate]\n}\n`,'README.md':AZURE_STRUCTURED_GUIDE};
+}
+
+export const AZURE_STRUCTURED_GUIDE=`# Azure structured AI application
+
+Each explicitly selected azure-structured-app block is a composed application module: Linux App Service, browser, API, user-assigned runtime identity, regional Azure OpenAI account/deployment, two Entra app registrations, an API scope/role, and an assignment of an existing company group. It does not create users/groups, import existing applications or implement arbitrary other blocks. See resource-schedule.json for unresolved scope. Public TLS endpoints use identity enforcement; private networking is not implemented by this module.
+
+The emitted Python 3.13 application verifies signed RS256 Entra v2 access tokens for the exact tenant, API audience, browser client, delegated scope and assigned WorkspaceUser role. ID tokens, app-only tokens and forwarded identity headers grant no API access. Keys are fetched from the fixed tenant endpoint with bounded retrieval and rotation caching. Bearer tokens authorize until expiry: group removal, disabling a user and logout do not immediately revoke an already issued token. Tenant Conditional Access/MFA and any continuous-revocation requirement require destination policy/engineering and real tests. Entra P1/P2 is needed for group assignments. Provisioning Entra registrations/role assignments needs separately reviewed administrator/Graph permissions; the runtime receives none of those permissions.
+
+Runtime identity receives model inference access and account-scoped Reader for policy checks, plus AcrPull on the exact existing registry. These are not subscription-wide Owner grants. Registry mode must support AcrPull and accept ARM audience tokens for managed-identity pulls; an ABAC-enabled or network-protected registry needs a different reviewed assignment/network integration. No static credential, model key or client secret is emitted. Protect Terraform state: providers may retain sensitive service attributes even when no output exposes a key.
+
+Input/results are not persisted by the app. Before inference, a read-only ARM check requires the exact model account and ContentLogging=false capability. This capability requires approved modified abuse monitoring; the app cannot self-approve it. Missing approval, policy outage or unknown state blocks inference with a clear setup error, without sending the user input to the model. It never modifies account-wide policy. Review provider processing, monitoring, residency and account terms separately; Standard regional model deployment alone does not prove whole-system residency. Model/account availability, compatible model/version, quotas, prices and this policy approval need authorized destination checks. No availability or privacy approval is invented.
+
+Build/test the emitted applications first using each applications/*/BUILD.md. Build and push to an existing reviewed ACR, retain exact source/image digests, then supply deployment inputs. No Terraform provisioners or bootstrap cloud actions run automatically. Register Microsoft.Web, Microsoft.CognitiveServices and Microsoft.ManagedIdentity separately under authorized subscription control; automatic registration is disabled. Both providers are pinned to the expected tenant/subscription and use the operator credential chain.
+
+The API requests strict JSON Schema output with the documented response_format contract and independently validates the returned JSON. Select a regional deployment/version that supports structured outputs; unsupported model/configuration errors fail closed, without silently switching model or removing the schema. String length limits remain enforced by the application because the provider schema subset does not support maxLength.
+
+Use terraform init -backend=false, terraform validate and terraform test for provider schemas and mock configuration checks. Review actual destination inputs and an authorized plan separately. Production is blocked until state, backup and operations are reviewed. App Service B1 and a single process are an initial bounded deployment, not a high-availability SLA. Per-process concurrency/output limits and model quota bound traffic; they are not an invoice cap. No request bodies, tokens or model text are logged by the application; review platform-level logging separately.
+
+The model returns flat schema-checked fields with a human-review marker. No tool/action is executed. Output validation does not prove factual or classification accuracy. Run representative model-quality tests, real sign-in/role/expiry tests, image startup/scan, policy checks and an authorized account plan before deployment. This export itself proves no deployment.
+
+References:
+- https://learn.microsoft.com/en-us/entra/identity-platform/claims-validation
+- https://learn.microsoft.com/en-us/entra/identity-platform/howto-add-app-roles-in-apps
+- https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/abuse-monitoring
+- https://learn.microsoft.com/en-us/rest/api/aifoundry/azureopenai/chat
+- https://registry.terraform.io/providers/hashicorp/azurerm/4.81.0/docs/resources/linux_web_app
+- https://registry.terraform.io/providers/hashicorp/azuread/3.10.0/docs
+`;